chore: generate

packages/app/src/app.tsx

@@ -43,7 +43,6 @@ import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServerProvider, serverName, useServer } from "@/context/server"
 import { SettingsProvider, useSettings } from "@/context/settings"
 import { TerminalProvider } from "@/context/terminal"
-import { WslServersProvider } from "@/context/wsl-servers"
 import DirectoryLayout from "@/pages/directory-layout"
 import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
@@ -72,7 +71,7 @@ declare global {
     __OPENCODE__?: {
       updaterEnabled?: boolean
       deepLinks?: string[]
-      activeServer?: string
+      wsl?: boolean
     }
     api?: {
       setTitlebar?: (theme: { mode: "light" | "dark" }) => Promise<void>
@@ -172,13 +171,11 @@ export function AppBaseProviders(props: ParentProps<{ locale?: Locale }>) {
               }}
             >
               <QueryProvider>
-                <WslServersProvider>
-                  <DialogProvider>
-                    <MarkedProvider>
-                      <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
-                    </MarkedProvider>
-                  </DialogProvider>
-                </WslServersProvider>
+                <DialogProvider>
+                  <MarkedProvider>
+                    <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
+                  </MarkedProvider>
+                </DialogProvider>
               </QueryProvider>
             </ErrorBoundary>
           </UiI18nBridge>
@@ -301,11 +298,11 @@ function ConnectionError(props: { onRetry?: () => void; onServerSelected?: (key:
   )
 }
 
-function ServerKey(props: { children: (key: ServerConnection.Key) => JSX.Element }) {
+function ServerKey(props: ParentProps) {
   const server = useServer()
   return (
     <Show when={server.key} keyed>
-      {(key) => props.children(key)}
+      {props.children}
     </Show>
   )
 }
@@ -322,24 +319,22 @@ export function AppInterface(props: {
       <ServersProvider>
         <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
           <ServerKey>
-            {() => (
-              <QueryProvider>
-                <ServerSDKProvider>
-                  <ServerSyncProvider>
-                    <Dynamic
-                      component={props.router ?? Router}
-                      root={(routerProps) => <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>}
-                    >
-                      <Route path="/" component={HomeRoute} />
-                      <Route path="/:dir" component={DirectoryLayout}>
-                        <Route path="/" component={() => <Navigate href="session" />} />
-                        <Route path="/session/:id?" component={SessionRoute} />
-                      </Route>
-                    </Dynamic>
-                  </ServerSyncProvider>
-                </ServerSDKProvider>
-              </QueryProvider>
-            )}
+            <QueryProvider>
+              <ServerSDKProvider>
+                <ServerSyncProvider>
+                  <Dynamic
+                    component={props.router ?? Router}
+                    root={(routerProps) => <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>}
+                  >
+                    <Route path="/" component={HomeRoute} />
+                    <Route path="/:dir" component={DirectoryLayout}>
+                      <Route path="/" component={() => <Navigate href="session" />} />
+                      <Route path="/session/:id?" component={SessionRoute} />
+                    </Route>
+                  </Dynamic>
+                </ServerSyncProvider>
+              </ServerSDKProvider>
+            </QueryProvider>
           </ServerKey>
         </ConnectionGate>
       </ServersProvider>

packages/app/src/components/dialog-select-server.tsx

@@ -5,26 +5,20 @@ import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
 import { Icon } from "@opencode-ai/ui/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { List } from "@opencode-ai/ui/list"
-import { Spinner } from "@opencode-ai/ui/spinner"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { useMutation } from "@tanstack/solid-query"
-import { showToast } from "@opencode-ai/ui/toast"
-import { batch, createEffect, createMemo, createResource, For, onCleanup, Show, untrack } from "solid-js"
+import { showToast } from "@/utils/toast"
+import { useNavigate } from "@solidjs/router"
+import { createEffect, createMemo, createResource, onCleanup, Show } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { DialogWslServer } from "@/components/dialog-wsl-server"
 import { ServerHealthIndicator, ServerRow } from "@/components/server/server-row"
 import { useLanguage } from "@/context/language"
 import { usePlatform } from "@/context/platform"
 import { normalizeServerUrl, ServerConnection, useServer } from "@/context/server"
-import { useWslServers } from "@/context/wsl-servers"
 import { type ServerHealth, useCheckServerHealth } from "@/utils/server-health"
 
 const DEFAULT_USERNAME = "opencode"
 
-interface DialogSelectServerProps {
-  onNavigateHome?: () => void
-}
-
 interface ServerFormProps {
   value: string
   name: string
@@ -33,6 +27,7 @@ interface ServerFormProps {
   placeholder: string
   busy: boolean
   error: string
+  status: boolean | undefined
   onChange: (value: string) => void
   onNameChange: (value: string) => void
   onUsernameChange: (value: string) => void
@@ -49,17 +44,15 @@ function showRequestError(language: ReturnType<typeof useLanguage>, err: unknown
   })
 }
 
-function isWslSidecar(conn: ServerConnection.Any): conn is ServerConnection.Sidecar & { variant: "wsl" } {
-  return conn.type === "sidecar" && conn.variant === "wsl"
-}
-
 function useDefaultServer() {
   const language = useLanguage()
   const platform = usePlatform()
-  const [defaultKey, defaultActions] = createResource(
+  const [defaultKey, defaultUrlActions] = createResource(
     async () => {
       try {
-        return (await platform.getDefaultServer?.()) ?? null
+        const key = await platform.getDefaultServer?.()
+        if (!key) return null
+        return key
       } catch (err) {
         showRequestError(language, err)
         return null
@@ -67,18 +60,52 @@ function useDefaultServer() {
     },
     { initialValue: null },
   )
+
   const canDefault = createMemo(() => !!platform.getDefaultServer && !!platform.setDefaultServer)
   const setDefault = async (key: ServerConnection.Key | null) => {
     try {
       await platform.setDefaultServer?.(key)
-      defaultActions.mutate(key)
+      defaultUrlActions.mutate(key)
     } catch (err) {
       showRequestError(language, err)
     }
   }
+
   return { defaultKey, canDefault, setDefault }
 }
 
+function useServerPreview() {
+  const checkServerHealth = useCheckServerHealth()
+
+  const looksComplete = (value: string) => {
+    const normalized = normalizeServerUrl(value)
+    if (!normalized) return false
+    const host = normalized.replace(/^https?:\/\//, "").split("/")[0]
+    if (!host) return false
+    if (host.includes("localhost") || host.startsWith("127.0.0.1")) return true
+    return host.includes(".") || host.includes(":")
+  }
+
+  const previewStatus = async (
+    value: string,
+    username: string,
+    password: string,
+    setStatus: (value: boolean | undefined) => void,
+  ) => {
+    setStatus(undefined)
+    if (!looksComplete(value)) return
+    const normalized = normalizeServerUrl(value)
+    if (!normalized) return
+    const http: ServerConnection.HttpBase = { url: normalized }
+    if (username) http.username = username
+    if (password) http.password = password
+    const result = await checkServerHealth(http)
+    setStatus(result.healthy)
+  }
+
+  return { previewStatus }
+}
+
 function ServerForm(props: ServerFormProps) {
   const language = useLanguage()
   const keyDown = (event: KeyboardEvent) => {
@@ -144,18 +171,15 @@ function ServerForm(props: ServerFormProps) {
   )
 }
 
-export function DialogSelectServer(props: DialogSelectServerProps = {}) {
+export function DialogSelectServer() {
+  const navigate = useNavigate()
   const dialog = useDialog()
   const server = useServer()
   const platform = usePlatform()
   const language = useLanguage()
-  const wslServers = useWslServers()
-  const defaultServer = useDefaultServer()
+  const { defaultKey, canDefault, setDefault } = useDefaultServer()
+  const { previewStatus } = useServerPreview()
   const checkServerHealth = useCheckServerHealth()
-  let disposed = false
-  onCleanup(() => {
-    disposed = true
-  })
   const [store, setStore] = createStore({
     status: {} as Record<ServerConnection.Key, ServerHealth | undefined>,
     addServer: {
@@ -165,9 +189,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       password: "",
       error: "",
       showForm: false,
-    },
-    addWsl: {
-      showWizard: false,
+      status: undefined as boolean | undefined,
     },
     editServer: {
       id: undefined as string | undefined,
@@ -176,6 +198,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       username: "",
       password: "",
       error: "",
+      status: undefined as boolean | undefined,
     },
   })
 
@@ -187,6 +210,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       password: "",
       error: "",
       showForm: false,
+      status: undefined,
     })
   }
   const resetEdit = () => {
@@ -197,6 +221,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       username: "",
       password: "",
       error: "",
+      status: undefined,
     })
   }
 
@@ -269,32 +294,6 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
     },
   }))
 
-  const removeWslMutation = useMutation(() => ({
-    mutationFn: async (key: ServerConnection.Key) => {
-      await platform.wslServers?.removeServer(key)
-      return key
-    },
-    onSuccess: async (key) => {
-      if (defaultServer.defaultKey() === key) await defaultServer.setDefault(null)
-      server.remove(key)
-    },
-    onError: (err) => showRequestError(language, err),
-  }))
-
-  const retryWslMutation = useMutation(() => ({
-    mutationFn: async (key: ServerConnection.Key) => {
-      await platform.wslServers?.startServer(key)
-    },
-    onError: (err) => showRequestError(language, err),
-  }))
-
-  const updateWslMutation = useMutation(() => ({
-    mutationFn: async (distro: string) => {
-      await platform.wslServers?.installOpencode(distro)
-    },
-    onError: (err) => showRequestError(language, err),
-  }))
-
   const replaceServer = (original: ServerConnection.Http, next: ServerConnection.Http) => {
     const active = server.key
     const newConn = server.add(next)
@@ -313,32 +312,6 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
   })
 
   const current = createMemo(() => items().find((x) => ServerConnection.key(x) === server.key) ?? items()[0])
-  const wslState = () => wslServers.data
-  const healthPollKey = createMemo(() =>
-    items()
-      .map((conn) =>
-        [ServerConnection.key(conn), conn.http.url, conn.http.username ?? "", conn.http.password ?? ""].join("\n"),
-      )
-      .join("\n\n"),
-  )
-  const health = (key: ServerConnection.Key) => store.status[key]
-  const wslRuntime = (conn: ServerConnection.Any) => {
-    if (!isWslSidecar(conn)) return
-    return wslState()?.servers.find((item) => item.config.id === ServerConnection.key(conn))?.runtime
-  }
-  const nonReadyWslServers = createMemo(() =>
-    (wslState()?.servers ?? []).filter((item) => item.runtime.kind !== "ready"),
-  )
-  const canRetryWsl = (conn: ServerConnection.Any) => {
-    const runtime = wslRuntime(conn)
-    return runtime?.kind === "failed" || runtime?.kind === "stopped"
-  }
-  const canRetryWslRuntime = (kind: string) => kind === "failed" || kind === "stopped"
-  const wslRuntimeLabel = (kind: string) => {
-    if (kind === "starting") return "Starting"
-    if (kind === "failed") return "Failed"
-    return "Stopped"
-  }
 
   const sortedItems = createMemo(() => {
     const list = items()
@@ -353,7 +326,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
     return list.slice().sort((a, b) => {
       if (a === active) return -1
       if (b === active) return 1
-      const diff = rank(health(ServerConnection.key(a))) - rank(health(ServerConnection.key(b)))
+      const diff = rank(store.status[ServerConnection.key(a)]) - rank(store.status[ServerConnection.key(b)])
       if (diff !== 0) return diff
       return (order.get(a) ?? 0) - (order.get(b) ?? 0)
     })
@@ -361,60 +334,39 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
 
   async function refreshHealth() {
     const results: Record<ServerConnection.Key, ServerHealth> = {}
-    const list = untrack(items)
     await Promise.all(
-      list.map(async (conn) => {
+      items().map(async (conn) => {
         results[ServerConnection.key(conn)] = await checkServerHealth(conn.http)
       }),
     )
-    if (disposed) return
     setStore("status", reconcile(results))
   }
 
   createEffect(() => {
-    healthPollKey()
+    items()
     void refreshHealth()
     const interval = setInterval(refreshHealth, 10_000)
     onCleanup(() => clearInterval(interval))
   })
 
-  const wslCheck = (conn: ServerConnection.Any) => {
-    if (!isWslSidecar(conn)) return null
-    return wslState()?.opencodeChecks[conn.distro] ?? null
-  }
-
   async function select(conn: ServerConnection.Any, persist?: boolean) {
-    if (!persist && health(ServerConnection.key(conn))?.healthy === false) return
-    const nextKey = ServerConnection.key(conn)
-    const changed = server.key !== nextKey
-
-    const navigateHome = () => props.onNavigateHome?.()
-
-    const apply = () => {
-      dialog.close()
-      if (persist && conn.type === "http") {
-        server.add(conn)
-        navigateHome()
-        return
-      }
-
-      batch(() => {
-        navigateHome()
-        server.setActive(nextKey)
-      })
-    }
-
-    if (!changed) {
-      await apply()
+    if (!persist && store.status[ServerConnection.key(conn)]?.healthy === false) return
+    dialog.close()
+    if (persist && conn.type === "http") {
+      server.add(conn)
+      navigate("/")
       return
     }
-
-    apply()
+    navigate("/")
+    queueMicrotask(() => server.setActive(ServerConnection.key(conn)))
   }
 
   const handleAddChange = (value: string) => {
     if (addMutation.isPending) return
     setStore("addServer", { url: value, error: "" })
+    void previewStatus(value, store.addServer.username, store.addServer.password, (next) =>
+      setStore("addServer", { status: next }),
+    )
   }
 
   const handleAddNameChange = (value: string) => {
@@ -425,16 +377,25 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
   const handleAddUsernameChange = (value: string) => {
     if (addMutation.isPending) return
     setStore("addServer", { username: value, error: "" })
+    void previewStatus(store.addServer.url, value, store.addServer.password, (next) =>
+      setStore("addServer", { status: next }),
+    )
   }
 
   const handleAddPasswordChange = (value: string) => {
     if (addMutation.isPending) return
     setStore("addServer", { password: value, error: "" })
+    void previewStatus(store.addServer.url, store.addServer.username, value, (next) =>
+      setStore("addServer", { status: next }),
+    )
   }
 
   const handleEditChange = (value: string) => {
     if (editMutation.isPending) return
     setStore("editServer", { value, error: "" })
+    void previewStatus(value, store.editServer.username, store.editServer.password, (next) =>
+      setStore("editServer", { status: next }),
+    )
   }
 
   const handleEditNameChange = (value: string) => {
@@ -445,15 +406,20 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
   const handleEditUsernameChange = (value: string) => {
     if (editMutation.isPending) return
     setStore("editServer", { username: value, error: "" })
+    void previewStatus(store.editServer.value, value, store.editServer.password, (next) =>
+      setStore("editServer", { status: next }),
+    )
   }
 
   const handleEditPasswordChange = (value: string) => {
     if (editMutation.isPending) return
     setStore("editServer", { password: value, error: "" })
+    void previewStatus(store.editServer.value, store.editServer.username, value, (next) =>
+      setStore("editServer", { status: next }),
+    )
   }
 
-  const mode = createMemo<"list" | "add-wsl" | "add" | "edit">(() => {
-    if (store.addWsl.showWizard) return "add-wsl"
+  const mode = createMemo<"list" | "add" | "edit">(() => {
     if (store.editServer.id) return "edit"
     if (store.addServer.showForm) return "add"
     return "list"
@@ -467,11 +433,9 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
   const resetForm = () => {
     resetAdd()
     resetEdit()
-    setStore("addWsl", "showWizard", false)
   }
 
   const startAdd = () => {
-    setStore("addWsl", "showWizard", false)
     resetEdit()
     setStore("addServer", {
       showForm: true,
@@ -480,11 +444,11 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       username: DEFAULT_USERNAME,
       password: "",
       error: "",
+      status: undefined,
     })
   }
 
   const startEdit = (conn: ServerConnection.Http) => {
-    setStore("addWsl", "showWizard", false)
     resetAdd()
     setStore("editServer", {
       id: conn.http.url,
@@ -493,22 +457,10 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
       username: conn.http.username ?? "",
       password: conn.http.password ?? "",
       error: "",
+      status: store.status[ServerConnection.key(conn)]?.healthy,
     })
   }
 
-  const startAddWsl = () => {
-    resetAdd()
-    resetEdit()
-    setStore("addWsl", "showWizard", true)
-  }
-
-  const handleAddedWsl = async (distro: string) => {
-    const key = ServerConnection.Key.make(`wsl:${distro}`)
-    setStore("addWsl", "showWizard", false)
-    const conn = items().find((item) => ServerConnection.key(item) === key)
-    if (conn) await select(conn)
-  }
-
   const submitForm = () => {
     if (mode() === "add") {
       if (addMutation.isPending) return
@@ -525,22 +477,14 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
 
   const isFormMode = createMemo(() => mode() !== "list")
   const isAddMode = createMemo(() => mode() === "add")
-  const isAddWslMode = createMemo(() => mode() === "add-wsl")
   const formBusy = createMemo(() => (isAddMode() ? addMutation.isPending : editMutation.isPending))
-  const canAddWsl = createMemo(() => !!platform.wslServers && platform.os === "windows")
 
   const formTitle = createMemo(() => {
     if (!isFormMode()) return language.t("dialog.server.title")
     return (
       <div class="flex items-center gap-2 -ml-2">
         <IconButton icon="arrow-left" variant="ghost" onClick={resetForm} aria-label={language.t("common.goBack")} />
-        <span>
-          {isAddWslMode()
-            ? "Add WSL server"
-            : isAddMode()
-              ? language.t("dialog.server.add.title")
-              : language.t("dialog.server.edit.title")}
-        </span>
+        <span>{isAddMode() ? language.t("dialog.server.add.title") : language.t("dialog.server.edit.title")}</span>
       </div>
     )
   })
@@ -551,126 +495,37 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
     resetEdit()
   })
 
-  async function handleRemove(key: ServerConnection.Key) {
-    server.remove(key)
-    if (defaultServer.defaultKey() === key) await defaultServer.setDefault(null)
+  async function handleRemove(url: ServerConnection.Key) {
+    server.remove(url)
+    if ((await platform.getDefaultServer?.()) === url) {
+      void platform.setDefaultServer?.(null)
+    }
   }
 
   return (
-    <Dialog
-      title={formTitle()}
-      fit={isAddWslMode()}
-      class={isAddWslMode() ? "[&_[data-slot=dialog-body]]:flex-none [&_[data-slot=dialog-body]]:overflow-visible" : undefined}
-    >
-      <div class={isAddWslMode() ? "flex flex-col gap-2" : "flex flex-1 min-h-0 flex-col gap-2"}>
+    <Dialog title={formTitle()}>
+      <div class="flex flex-1 min-h-0 flex-col gap-2">
         <Show
           when={!isFormMode()}
           fallback={
-            <Show
-              when={isAddWslMode()}
-              fallback={
-                <ServerForm
-                  value={isAddMode() ? store.addServer.url : store.editServer.value}
-                  name={isAddMode() ? store.addServer.name : store.editServer.name}
-                  username={isAddMode() ? store.addServer.username : store.editServer.username}
-                  password={isAddMode() ? store.addServer.password : store.editServer.password}
-                  placeholder={language.t("dialog.server.add.placeholder")}
-                  busy={formBusy()}
-                  error={isAddMode() ? store.addServer.error : store.editServer.error}
-                  onChange={isAddMode() ? handleAddChange : handleEditChange}
-                  onNameChange={isAddMode() ? handleAddNameChange : handleEditNameChange}
-                  onUsernameChange={isAddMode() ? handleAddUsernameChange : handleEditUsernameChange}
-                  onPasswordChange={isAddMode() ? handleAddPasswordChange : handleEditPasswordChange}
-                  onSubmit={submitForm}
-                  onBack={resetForm}
-                />
-              }
-            >
-              <DialogWslServer onAdded={handleAddedWsl} />
-            </Show>
+            <ServerForm
+              value={isAddMode() ? store.addServer.url : store.editServer.value}
+              name={isAddMode() ? store.addServer.name : store.editServer.name}
+              username={isAddMode() ? store.addServer.username : store.editServer.username}
+              password={isAddMode() ? store.addServer.password : store.editServer.password}
+              placeholder={language.t("dialog.server.add.placeholder")}
+              busy={formBusy()}
+              error={isAddMode() ? store.addServer.error : store.editServer.error}
+              status={isAddMode() ? store.addServer.status : store.editServer.status}
+              onChange={isAddMode() ? handleAddChange : handleEditChange}
+              onNameChange={isAddMode() ? handleAddNameChange : handleEditNameChange}
+              onUsernameChange={isAddMode() ? handleAddUsernameChange : handleEditUsernameChange}
+              onPasswordChange={isAddMode() ? handleAddPasswordChange : handleEditPasswordChange}
+              onSubmit={submitForm}
+              onBack={resetForm}
+            />
           }
         >
-          <Show when={nonReadyWslServers().length > 0}>
-            <div class="px-5">
-              <div class="bg-surface-base rounded-md overflow-hidden">
-                <For each={nonReadyWslServers()}>
-                  {(item) => {
-                    const key = ServerConnection.Key.make(item.config.id)
-                    const retryable = () => canRetryWslRuntime(item.runtime.kind)
-                    return (
-                      <div class="min-h-14 p-3 flex items-center gap-3 border-b border-border-weak-base last:border-b-0">
-                        <div
-                          classList={{
-                            "size-1.5 rounded-full shrink-0": true,
-                            "bg-icon-critical-base": item.runtime.kind === "failed",
-                            "bg-border-weak-base": item.runtime.kind !== "failed",
-                          }}
-                        />
-                        <div class="flex items-center gap-2 min-w-0 flex-1">
-                          <span class="text-14-medium text-text-base truncate">{item.config.distro}</span>
-                          <span class="text-11-regular text-text-weak border border-border-weak-base bg-surface-base px-1.5 py-0.5 rounded-md shrink-0">
-                            WSL
-                          </span>
-                          <Show when={defaultServer.defaultKey() === key}>
-                            <span class="text-text-base bg-surface-base text-14-regular px-1.5 rounded-xs shrink-0">
-                              {language.t("dialog.server.status.default")}
-                            </span>
-                          </Show>
-                          <span class="text-12-regular text-text-weak truncate">
-                            {wslRuntimeLabel(item.runtime.kind)}
-                          </span>
-                        </div>
-                        <DropdownMenu>
-                          <DropdownMenu.Trigger
-                            as={IconButton}
-                            icon="dot-grid"
-                            variant="ghost"
-                            class="shrink-0 size-8 hover:bg-surface-base-hover data-[expanded]:bg-surface-base-active"
-                            onClick={(e: MouseEvent) => e.stopPropagation()}
-                            onPointerDown={(e: PointerEvent) => e.stopPropagation()}
-                          />
-                          <DropdownMenu.Portal>
-                            <DropdownMenu.Content class="mt-1">
-                              <Show when={retryable()}>
-                                <DropdownMenu.Item onSelect={() => retryWslMutation.mutate(key)}>
-                                  <DropdownMenu.ItemLabel>Retry start</DropdownMenu.ItemLabel>
-                                </DropdownMenu.Item>
-                              </Show>
-                              <Show when={defaultServer.canDefault() && defaultServer.defaultKey() !== key}>
-                                <DropdownMenu.Item onSelect={() => void defaultServer.setDefault(key)}>
-                                  <DropdownMenu.ItemLabel>
-                                    {language.t("dialog.server.menu.default")}
-                                  </DropdownMenu.ItemLabel>
-                                </DropdownMenu.Item>
-                              </Show>
-                              <Show when={defaultServer.canDefault() && defaultServer.defaultKey() === key}>
-                                <DropdownMenu.Item onSelect={() => void defaultServer.setDefault(null)}>
-                                  <DropdownMenu.ItemLabel>
-                                    {language.t("dialog.server.menu.defaultRemove")}
-                                  </DropdownMenu.ItemLabel>
-                                </DropdownMenu.Item>
-                              </Show>
-                              <Show when={retryable() || defaultServer.canDefault()}>
-                                <DropdownMenu.Separator />
-                              </Show>
-                              <DropdownMenu.Item
-                                onSelect={() => removeWslMutation.mutate(key)}
-                                class="text-text-on-critical-base hover:bg-surface-critical-weak"
-                              >
-                                <DropdownMenu.ItemLabel>
-                                  {language.t("dialog.server.menu.delete")}
-                                </DropdownMenu.ItemLabel>
-                              </DropdownMenu.Item>
-                            </DropdownMenu.Content>
-                          </DropdownMenu.Portal>
-                        </DropdownMenu>
-                      </div>
-                    )
-                  }}
-                </For>
-              </div>
-            </div>
-          </Show>
           <List
             search={{
               placeholder: language.t("dialog.server.search.placeholder"),
@@ -679,7 +534,7 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
             noInitialSelection
             emptyMessage={language.t("dialog.server.empty")}
             items={sortedItems}
-            key={(x) => ServerConnection.key(x)}
+            key={(x) => x.http.url}
             onSelect={(x) => {
               if (x) void select(x)
             }}
@@ -688,35 +543,18 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
           >
             {(i) => {
               const key = ServerConnection.key(i)
-              const wsl = isWslSidecar(i)
-              const wslDistro = wsl ? i.distro : undefined
-              const blocked = () => health(key)?.healthy === false
-              const canChangeDefault = () => defaultServer.canDefault() && (i.type === "http" || wsl)
-              const canRemove = () => i.type === "http" || wsl
-              const opencodeAction = () => {
-                const check = wslCheck(i)
-                if (!check) return null
-                if (!check.resolvedPath) return "Install OpenCode"
-                if (check.matchesDesktop === false) return "Update OpenCode"
-                return null
-              }
-              const updating = () => {
-                const job = wslState()?.job
-                return job?.kind === "install-opencode" && job.distro === wslDistro
-              }
               return (
                 <div class="flex items-center gap-3 min-w-0 flex-1 w-full group/item">
                   <div class="flex flex-col h-full items-start w-5">
-                    <ServerHealthIndicator health={health(key)} />
+                    <ServerHealthIndicator health={store.status[key]} />
                   </div>
                   <ServerRow
                     conn={i}
-                    dimmed={blocked()}
-                    status={health(key)}
-                    version={wslCheck(i)?.version ?? undefined}
+                    dimmed={store.status[key]?.healthy === false}
+                    status={store.status[key]}
                     class="flex items-center gap-3 min-w-0 flex-1"
                     badge={
-                      <Show when={defaultServer.defaultKey() === ServerConnection.key(i)}>
+                      <Show when={defaultKey() === ServerConnection.key(i)}>
                         <span class="text-text-base bg-surface-base text-14-regular px-1.5 rounded-xs">
                           {language.t("dialog.server.status.default")}
                         </span>
@@ -724,32 +562,12 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
                     }
                     showCredentials
                   />
-                  <div class="flex items-center justify-center gap-3 pl-4">
-                    <Show when={wsl && opencodeAction()}>
-                      {(label) => (
-                        <Button
-                          variant="secondary"
-                          size="small"
-                          disabled={!!wslState()?.job}
-                          class="shrink-0"
-                          onPointerDown={(e: PointerEvent) => e.stopPropagation()}
-                          onClick={(e: MouseEvent) => {
-                            e.stopPropagation()
-                            if (wslDistro) updateWslMutation.mutate(wslDistro)
-                          }}
-                        >
-                          <Show when={updating()}>
-                            <Spinner class="size-3.5 shrink-0" />
-                          </Show>
-                          {label()}
-                        </Button>
-                      )}
-                    </Show>
+                  <div class="flex items-center justify-center gap-4 pl-4">
                     <Show when={ServerConnection.key(current()) === key}>
                       <Icon name="check" class="h-6" />
                     </Show>
 
-                    <Show when={i.type === "http" || i.type === "sidecar"}>
+                    <Show when={i.type === "http"}>
                       <DropdownMenu>
                         <DropdownMenu.Trigger
                           as={IconButton}
@@ -761,54 +579,35 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
                         />
                         <DropdownMenu.Portal>
                           <DropdownMenu.Content class="mt-1">
-                            <Show when={i.type === "http"}>
-                              <DropdownMenu.Item
-                                onSelect={() => {
-                                  if (i.type !== "http") return
-                                  startEdit(i)
-                                }}
-                              >
-                                <DropdownMenu.ItemLabel>{language.t("dialog.server.menu.edit")}</DropdownMenu.ItemLabel>
-                              </DropdownMenu.Item>
-                            </Show>
-                            <Show when={wsl && canRetryWsl(i)}>
-                              <DropdownMenu.Item onSelect={() => retryWslMutation.mutate(key)}>
-                                <DropdownMenu.ItemLabel>Retry start</DropdownMenu.ItemLabel>
-                              </DropdownMenu.Item>
-                            </Show>
-                            <Show when={canChangeDefault() && defaultServer.defaultKey() !== key}>
-                              <DropdownMenu.Item onSelect={() => void defaultServer.setDefault(key)}>
+                            <DropdownMenu.Item
+                              onSelect={() => {
+                                if (i.type !== "http") return
+                                startEdit(i)
+                              }}
+                            >
+                              <DropdownMenu.ItemLabel>{language.t("dialog.server.menu.edit")}</DropdownMenu.ItemLabel>
+                            </DropdownMenu.Item>
+                            <Show when={canDefault() && defaultKey() !== key}>
+                              <DropdownMenu.Item onSelect={() => setDefault(key)}>
                                 <DropdownMenu.ItemLabel>
                                   {language.t("dialog.server.menu.default")}
                                 </DropdownMenu.ItemLabel>
                               </DropdownMenu.Item>
                             </Show>
-                            <Show when={canChangeDefault() && defaultServer.defaultKey() === key}>
-                              <DropdownMenu.Item onSelect={() => void defaultServer.setDefault(null)}>
+                            <Show when={canDefault() && defaultKey() === key}>
+                              <DropdownMenu.Item onSelect={() => setDefault(null)}>
                                 <DropdownMenu.ItemLabel>
                                   {language.t("dialog.server.menu.defaultRemove")}
                                 </DropdownMenu.ItemLabel>
                               </DropdownMenu.Item>
                             </Show>
-                            <Show when={canRemove() && (i.type === "http" || canChangeDefault() || canRetryWsl(i))}>
-                              <DropdownMenu.Separator />
-                            </Show>
-                            <Show when={canRemove()}>
-                              <DropdownMenu.Item
-                                onSelect={() => {
-                                  if (wsl) {
-                                    removeWslMutation.mutate(key)
-                                    return
-                                  }
-                                  void handleRemove(key)
-                                }}
-                                class="text-text-on-critical-base hover:bg-surface-critical-weak"
-                              >
-                                <DropdownMenu.ItemLabel>
-                                  {language.t("dialog.server.menu.delete")}
-                                </DropdownMenu.ItemLabel>
-                              </DropdownMenu.Item>
-                            </Show>
+                            <DropdownMenu.Separator />
+                            <DropdownMenu.Item
+                              onSelect={() => handleRemove(ServerConnection.key(i))}
+                              class="text-text-on-critical-base hover:bg-surface-critical-weak"
+                            >
+                              <DropdownMenu.ItemLabel>{language.t("dialog.server.menu.delete")}</DropdownMenu.ItemLabel>
+                            </DropdownMenu.Item>
                           </DropdownMenu.Content>
                         </DropdownMenu.Portal>
                       </DropdownMenu>
@@ -822,32 +621,17 @@ export function DialogSelectServer(props: DialogSelectServerProps = {}) {
 
         <div class="shrink-0 px-5 pb-5">
           <Show
-            when={!isAddWslMode() && isFormMode()}
+            when={isFormMode()}
             fallback={
-              <Show when={!isAddWslMode()}>
-                <div class="flex items-center gap-2">
-                  <Button
-                    variant="secondary"
-                    icon="plus-small"
-                    size="large"
-                    onClick={startAdd}
-                    class="py-1.5 pl-1.5 pr-3 flex items-center gap-1.5"
-                  >
-                    {language.t("dialog.server.add.button")}
-                  </Button>
-                  <Show when={canAddWsl()}>
-                    <Button
-                      variant="secondary"
-                      icon="plus-small"
-                      size="large"
-                      onClick={startAddWsl}
-                      class="py-1.5 pl-1.5 pr-3 flex items-center gap-1.5"
-                    >
-                      Add WSL
-                    </Button>
-                  </Show>
-                </div>
-              </Show>
+              <Button
+                variant="secondary"
+                icon="plus-small"
+                size="large"
+                onClick={startAdd}
+                class="py-1.5 pl-1.5 pr-3 flex items-center gap-1.5"
+              >
+                {language.t("dialog.server.add.button")}
+              </Button>
             }
           >
             <Button variant="primary" size="large" onClick={submitForm} disabled={formBusy()} class="px-3 py-1.5">

packages/app/src/components/dialog-wsl-server.tsx

@@ -1,582 +0,0 @@
-import { Button } from "@opencode-ai/ui/button"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { Spinner } from "@opencode-ai/ui/spinner"
-import { showToast } from "@opencode-ai/ui/toast"
-import { createEffect, createMemo, For, Match, onCleanup, Show, Switch } from "solid-js"
-import { createStore } from "solid-js/store"
-import { useLanguage } from "@/context/language"
-import { usePlatform } from "@/context/platform"
-import { useWslServers } from "@/context/wsl-servers"
-
-type WslServerStep = "wsl" | "distro" | "opencode"
-
-const STEPS: WslServerStep[] = ["wsl", "distro", "opencode"]
-
-function isHiddenDistro(name: string) {
-  return /^docker-desktop(?:-data)?$/i.test(name)
-}
-
-interface DialogWslServerProps {
-  onAdded?: (distro: string) => void | Promise<void>
-}
-
-export function DialogWslServer(props: DialogWslServerProps = {}) {
-  const language = useLanguage()
-  const platform = usePlatform()
-  const dialog = useDialog()
-  const wslServers = useWslServers()
-  const api = platform.wslServers!
-  const [store, setStore] = createStore({
-    step: undefined as WslServerStep | undefined,
-    selectedDistro: null as string | null,
-    installTarget: undefined as string | undefined,
-    adding: false,
-  })
-  const current = () => wslServers.data
-  let disposed = false
-  onCleanup(() => {
-    disposed = true
-  })
-  const busy = createMemo(() => !!current()?.job || store.adding)
-  const selectedProbe = createMemo(() => {
-    const distro = store.selectedDistro
-    if (!distro) return null
-    return current()?.distroProbes[distro] ?? null
-  })
-  const selectedInstalled = createMemo(() => {
-    const distro = store.selectedDistro
-    if (!distro) return null
-    return (current()?.installed ?? []).find((item) => item.name === distro) ?? null
-  })
-  const visibleInstalledDistros = createMemo(() =>
-    (current()?.installed ?? []).filter((item) => !isHiddenDistro(item.name)),
-  )
-  const visibleOnlineDistros = createMemo(() => (current()?.online ?? []).filter((item) => !isHiddenDistro(item.name)))
-  const defaultInstalledDistro = createMemo(() => visibleInstalledDistros().find((item) => item.isDefault) ?? null)
-  const opencodeCheck = createMemo(() => {
-    const distro = store.selectedDistro
-    if (!distro) return null
-    return current()?.opencodeChecks[distro] ?? null
-  })
-  const distroWarningProbe = createMemo(() => {
-    const probe = selectedProbe()
-    if (!probe) return null
-    if (distroReady()) return null
-    return probe
-  })
-  const distroUnavailableMessage = createMemo(() => {
-    const probe = distroWarningProbe()
-    const distro = store.selectedDistro
-    if (!probe || probe.canExecute || !distro) return null
-    if (!selectedInstalled()) return `${distro} is not installed yet.`
-    return `Open ${distro} once to finish setup.`
-  })
-  const distroMissingTools = createMemo(() => {
-    const probe = distroWarningProbe()
-    if (!probe?.canExecute) return null
-    if (probe.hasBash && probe.hasCurl) return null
-    return probe
-  })
-  const existingServerDistros = createMemo(() => new Set((current()?.servers ?? []).map((item) => item.config.distro)))
-  const addableInstalledDistros = createMemo(() => {
-    return visibleInstalledDistros().filter((item) => !existingServerDistros().has(item.name))
-  })
-  const installableDistros = createMemo(() => {
-    const online = visibleOnlineDistros()
-    const installed = new Set(visibleInstalledDistros().map((item) => item.name))
-    const hasVersionedUbuntu = online.some((item) => /^Ubuntu-\d/.test(item.name))
-    return online
-      .filter((item) => !installed.has(item.name))
-      .filter((item) => !(item.name === "Ubuntu" && hasVersionedUbuntu))
-  })
-  const installTarget = createMemo(() => installableDistros().find((item) => item.name === store.installTarget) ?? null)
-  const installingDistro = createMemo(() => current()?.job?.kind === "install-distro")
-  const installingOpencode = createMemo(() => {
-    const job = current()?.job
-    return job?.kind === "install-opencode" && job.distro === store.selectedDistro
-  })
-  const wslReady = createMemo(() => !!current()?.runtime?.available && !current()?.pendingRestart)
-  const distroReady = createMemo(() => {
-    const probe = selectedProbe()
-    if (!probe || !store.selectedDistro) return false
-    if (selectedInstalled()?.version === 1) return false
-    return probe.canExecute && probe.hasBash && probe.hasCurl
-  })
-  const opencodeReady = createMemo(() => {
-    const check = opencodeCheck()
-    return !!check?.resolvedPath && !check.error
-  })
-  const allReady = createMemo(() => wslReady() && distroReady() && opencodeReady())
-  const addDisabled = createMemo(() => {
-    const job = current()?.job
-    if (!job) return store.adding
-    return store.adding || job.kind !== "probe-opencode"
-  })
-  const recommendedStep = createMemo<WslServerStep>(() => {
-    if (!wslReady()) return "wsl"
-    if (!distroReady()) return "distro"
-    return "opencode"
-  })
-  // activeStep falls back to recommendedStep when the user hasn't picked one.
-  // Once the user clicks a step tab we respect their choice rather than snapping
-  // them back when a probe result updates recommendedStep.
-  const activeStep = createMemo(() => store.step ?? recommendedStep())
-
-  const autoProbe = createMemo(() => {
-    const state = current()
-    if (!state || busy()) return null
-    if (state.pendingRestart) return null
-    if (!state.runtime) return { key: "runtime", run: () => api.probeRuntime() }
-    if (!wslReady()) return null
-    if (!state.installed.length && !state.online.length) {
-      return { key: "distros", run: () => api.refreshDistros() }
-    }
-    const distro = store.selectedDistro
-    if (distro && !state.distroProbes[distro]) {
-      return { key: `probe-distro:${distro}`, run: () => api.probeDistro(distro) }
-    }
-    if (!distro || !distroReady()) return null
-    if (!state.opencodeChecks[distro]) {
-      return { key: `probe-opencode:${distro}`, run: () => api.probeOpencode(distro) }
-    }
-    return null
-  })
-
-  let lastAutoProbe: string | null = null
-  createEffect(() => {
-    const probe = autoProbe()
-    if (!probe || probe.key === lastAutoProbe) return
-    const key = probe.key
-    lastAutoProbe = key
-    void (async () => {
-      try {
-        await probe.run()
-      } catch (err) {
-        if (disposed) return
-        // Allow the same probe to run again when reactive inputs next change
-        // (e.g. user reselects a distro). Without this the user would be stuck
-        // on a transient wsl.exe failure until they pick a different distro.
-        if (lastAutoProbe === key) lastAutoProbe = null
-        requestError(language, err)
-      }
-    })()
-  })
-
-  createEffect(() => {
-    const state = current()
-    const distro = defaultInstalledDistro()
-    if (!state || !distro || busy()) return
-    if (store.selectedDistro) return
-    if (existingServerDistros().has(distro.name)) return
-    setStore("selectedDistro", distro.name)
-  })
-
-  createEffect(() => {
-    const distros = installableDistros()
-    if (!distros.length) {
-      if (store.installTarget) setStore("installTarget", undefined)
-      return
-    }
-    if (store.installTarget && distros.some((item) => item.name === store.installTarget)) return
-    setStore("installTarget", distros[0]!.name)
-  })
-
-  const wslMessage = createMemo(() => {
-    const state = current()
-    if (!state || state.job?.kind === "runtime") return "Checking WSL..."
-    if (state.pendingRestart) return "Windows needs a restart to finish installing WSL."
-    if (state.runtime?.available) return state.runtime.version ?? "WSL is ready."
-    return state.runtime?.error ?? "WSL is required to continue."
-  })
-
-  const distroMessage = createMemo(() => {
-    const state = current()
-    if (!state) return "Checking distros..."
-    const distro = store.selectedDistro
-    if (state.job?.kind === "install-distro") return `Installing ${state.job.distro}...`
-    if (state.job?.kind === "probe-distro") return `Checking ${state.job.distro}...`
-    if (state.job?.kind === "distros") return "Listing distros..."
-    if (distroUnavailableMessage()) return distroUnavailableMessage()!
-    if (selectedProbe() && distroReady()) return `${selectedProbe()!.name} is ready.`
-    if (distro) return `Finishing setup for ${distro}.`
-    return "Pick a distro or install one below."
-  })
-
-  const opencodeMessage = createMemo(() => {
-    const state = current()
-    if (!state) return "Checking OpenCode..."
-    const distro = store.selectedDistro
-    if (state.job?.kind === "probe-opencode" || state.job?.kind === "install-opencode") {
-      return distro ? `Checking OpenCode in ${distro}...` : "Checking OpenCode..."
-    }
-    if (opencodeCheck()?.error) return opencodeCheck()!.error
-    if (opencodeCheck()?.matchesDesktop === false) {
-      return distro ? `Update OpenCode in ${distro}.` : "Update OpenCode."
-    }
-    if (opencodeReady()) return distro ? `OpenCode is ready in ${distro}.` : "OpenCode is ready."
-    return distro ? `Install OpenCode in ${distro}.` : "Choose a distro first."
-  })
-
-  const run = async (action: () => Promise<unknown>) => {
-    try {
-      await action()
-    } catch (err) {
-      requestError(language, err)
-    }
-  }
-
-  const runSelectedDistro = (action: (distro: string) => Promise<unknown>) => {
-    const distro = store.selectedDistro
-    if (!distro) return
-    void run(() => action(distro))
-  }
-
-  const selectDistro = (name: string) => {
-    setStore("selectedDistro", name)
-    setStore("step", undefined)
-  }
-
-  const finish = async () => {
-    const distro = store.selectedDistro
-    if (!distro) return
-    setStore("adding", true)
-    try {
-      await api.addServer(distro)
-      if (props.onAdded) {
-        await props.onAdded(distro)
-      } else {
-        dialog.close()
-      }
-    } catch (err) {
-      requestError(language, err)
-    } finally {
-      setStore("adding", false)
-    }
-  }
-
-  const steps = createMemo(() => {
-    const active = activeStep()
-    const activeIndex = STEPS.indexOf(active)
-    const recommendedIndex = STEPS.indexOf(recommendedStep())
-    return STEPS.map((step) => {
-      const index = STEPS.indexOf(step)
-      return {
-        step,
-        title: step === "wsl" ? "WSL" : step === "distro" ? "Choose distro" : "OpenCode",
-        state:
-          active === step
-            ? "current"
-            : step === "wsl"
-              ? wslReady()
-                ? "done"
-                : "warning"
-              : step === "distro"
-                ? distroReady()
-                  ? "done"
-                  : index > activeIndex
-                    ? "locked"
-                    : "warning"
-                : opencodeCheck()?.matchesDesktop === false
-                  ? "warning"
-                  : opencodeReady()
-                    ? "done"
-                    : index > activeIndex
-                      ? "locked"
-                      : "warning",
-        locked: index > recommendedIndex,
-      }
-    })
-  })
-  const loadError = createMemo(() => {
-    const error = wslServers.error
-    if (!error) return "Failed to load WSL state."
-    return error instanceof Error ? error.message : String(error)
-  })
-
-  return (
-    <div class="px-5 pb-5 flex flex-col gap-4">
-      <Show when={!wslServers.isPending} fallback={<div class="px-1 py-6 text-14-regular text-text-weak">Loading...</div>}>
-        <Show when={!wslServers.isError} fallback={<div class="px-1 py-6 text-14-regular text-text-weak">{loadError()}</div>}>
-          <div class="flex gap-2 pb-1">
-            <For each={steps()}>
-              {(item) => (
-                <button
-                  type="button"
-                  class="basis-0 flex-1 min-w-0 rounded-md border px-3 py-2 text-left transition-colors"
-                  classList={{
-                    "border-border-strong-base bg-surface-base-hover": item.state === "current",
-                    "border-icon-success-base/40 bg-surface-base": item.state === "done",
-                    "border-border-weak-base bg-background-base opacity-60": item.state === "locked",
-                    "border-icon-warning-base/40 bg-surface-base": item.state === "warning",
-                  }}
-                  disabled={item.locked}
-                  onClick={() => setStore("step", item.step)}
-                >
-                  <div class="text-13-medium text-text-strong">{item.title}</div>
-                </button>
-              )}
-            </For>
-          </div>
-
-          <Switch>
-          <Match when={activeStep() === "wsl"}>
-            <div class="rounded-md bg-surface-base p-4 flex flex-col gap-3">
-              <div class="flex items-center justify-between gap-3">
-                <div class="text-14-medium text-text-strong">WSL</div>
-                <Show when={current()?.runtime && !wslReady() && !current()?.pendingRestart}>
-                  <Button
-                    variant="secondary"
-                    size="large"
-                    disabled={busy()}
-                    onClick={() => void run(() => api.installWsl())}
-                  >
-                    Install WSL
-                  </Button>
-                </Show>
-              </div>
-              <div class="text-12-regular text-text-weak whitespace-pre-wrap break-words">{wslMessage()}</div>
-              <Show when={current()?.pendingRestart}>
-                <div class="rounded-md border border-border-weak-base px-3 py-3 flex items-center justify-between gap-3">
-                  <div class="text-12-regular text-text-warning-base">Windows restart required.</div>
-                  <Button variant="secondary" size="large" onClick={() => void platform.restart()}>
-                    Relaunch OpenCode
-                  </Button>
-                </div>
-              </Show>
-              <div class="flex items-center justify-end">
-                <Button variant="secondary" size="large" disabled={busy() || !wslReady()} onClick={() => setStore("step", "distro")}>
-                  Next
-                </Button>
-              </div>
-            </div>
-          </Match>
-
-          <Match when={activeStep() === "distro"}>
-            <div class="rounded-md bg-surface-base p-4 flex flex-col gap-3">
-              <div class="flex items-center justify-between gap-3">
-                <div class="text-14-medium text-text-strong">Choose a distro</div>
-                <Show when={store.selectedDistro}>
-                  <Button
-                    variant="ghost"
-                    size="small"
-                    disabled={busy()}
-                    onClick={() => runSelectedDistro((distro) => api.probeDistro(distro))}
-                  >
-                    Refresh
-                  </Button>
-                </Show>
-              </div>
-              <div class="text-12-regular text-text-weak whitespace-pre-wrap break-words">{distroMessage()}</div>
-
-              <div class="flex flex-col gap-2">
-                <Show
-                  when={addableInstalledDistros().length > 0}
-                  fallback={
-                    <div class="text-12-regular text-text-weak">
-                      {visibleInstalledDistros().length
-                        ? "All installed distros are already added."
-                        : current()?.runtime?.available
-                          ? "No distros detected yet."
-                          : "Checking distros..."}
-                    </div>
-                  }
-                >
-                  <For each={addableInstalledDistros()}>
-                    {(item) => (
-                      <button
-                        type="button"
-                        class="rounded-md border border-border-weak-base px-3 py-2 text-left transition-colors"
-                        classList={{ "bg-surface-raised-base": store.selectedDistro === item.name }}
-                        onClick={() => selectDistro(item.name)}
-                      >
-                        <div class="text-13-medium text-text-strong">{item.name}</div>
-                        <Show when={item.isDefault}>
-                          <div class="text-12-regular text-text-weak">Default</div>
-                        </Show>
-                      </button>
-                    )}
-                  </For>
-                </Show>
-              </div>
-
-              <Show when={installableDistros().length > 0}>
-                <div class="rounded-md border border-border-weak-base p-2 flex flex-col gap-2">
-                  <div class="px-1 flex items-center justify-between gap-3">
-                    <div class="text-12-medium text-text-weak">Install</div>
-                    <div class="flex items-center gap-2 shrink-0">
-                      <Show when={installingDistro()}>
-                        <Spinner class="h-4 w-4 text-icon-info-base shrink-0" />
-                      </Show>
-                      <Button
-                        variant="secondary"
-                        size="small"
-                        disabled={busy() || !installTarget()}
-                        onClick={() => void run(() => api.installDistro(installTarget()!.name))}
-                      >
-                        {installingDistro() ? "Installing..." : "Install"}
-                      </Button>
-                    </div>
-                  </div>
-                  <div
-                    role="radiogroup"
-                    aria-label="Install distro"
-                    class="max-h-52 overflow-y-auto rounded-md bg-background-base"
-                  >
-                    <For each={installableDistros()}>
-                      {(item) => {
-                        const selected = () => store.installTarget === item.name
-                        return (
-                          <button
-                            type="button"
-                            role="radio"
-                            aria-checked={selected()}
-                            disabled={busy()}
-                            class="w-full px-3 py-2 flex items-center gap-3 text-left border-b border-border-weak-base last:border-b-0 transition-colors"
-                            classList={{
-                              "bg-surface-raised-base": selected(),
-                              "hover:bg-surface-base": !selected(),
-                            }}
-                            onClick={() => setStore("installTarget", item.name)}
-                          >
-                            <div
-                              class="mt-0.5 h-4 w-4 rounded-full border border-border-strong-base flex items-center justify-center shrink-0"
-                              classList={{ "border-text-strong": selected() }}
-                            >
-                              <div class="h-2 w-2 rounded-full bg-text-strong" classList={{ hidden: !selected() }} />
-                            </div>
-                            <div class="min-w-0 flex-1 text-13-medium text-text-strong truncate">{item.label}</div>
-                          </button>
-                        )
-                      }}
-                    </For>
-                  </div>
-                </div>
-              </Show>
-
-              <Show
-                when={
-                  selectedInstalled()?.version === 1 ||
-                  distroUnavailableMessage() ||
-                  distroMissingTools()
-                }
-              >
-                <div class="rounded-md border border-border-weak-base px-3 py-3 flex flex-col gap-1">
-                  <Show when={selectedInstalled()?.version === 1}>
-                    <div class="text-12-regular text-text-warning-base">WSL 2 is required.</div>
-                  </Show>
-                  <Show when={distroUnavailableMessage()}>
-                    {(message) => <div class="text-12-regular text-text-warning-base">{message()}</div>}
-                  </Show>
-                  <Show when={distroMissingTools()}>
-                    <div class="text-12-regular text-text-warning-base">This distro needs bash and curl.</div>
-                  </Show>
-                </div>
-              </Show>
-
-              <div class="flex items-center gap-2">
-                <Button
-                  variant="secondary"
-                  size="large"
-                  disabled={busy() || !selectedInstalled()}
-                  onClick={() => runSelectedDistro((distro) => api.openTerminal(distro))}
-                >
-                  Open terminal
-                </Button>
-                <Button
-                  variant="ghost"
-                  size="large"
-                  disabled={busy() || !store.selectedDistro}
-                  onClick={() => runSelectedDistro((distro) => api.probeDistro(distro))}
-                >
-                  Refresh
-                </Button>
-              </div>
-
-              <div class="flex items-center justify-end">
-                <Button
-                  variant="secondary"
-                  size="large"
-                  disabled={busy() || !store.selectedDistro || !distroReady()}
-                  onClick={() => setStore("step", "opencode")}
-                >
-                  Next
-                </Button>
-              </div>
-            </div>
-          </Match>
-
-          <Match when={activeStep() === "opencode"}>
-            <div class="rounded-md bg-surface-base p-4 flex flex-col gap-3">
-              <div class="flex items-center justify-between gap-3">
-                <div class="text-14-medium text-text-strong">OpenCode</div>
-                <div class="flex items-center gap-2">
-                  <Show when={store.selectedDistro}>
-                    <Button
-                      variant="ghost"
-                      size="large"
-                      disabled={busy()}
-                      onClick={() => runSelectedDistro((distro) => api.probeOpencode(distro))}
-                    >
-                      Refresh
-                    </Button>
-                  </Show>
-                  <Show when={!opencodeReady() || opencodeCheck()?.matchesDesktop === false}>
-                    <Button
-                      variant="secondary"
-                      size="large"
-                      disabled={busy()}
-                      onClick={() => runSelectedDistro((distro) => api.installOpencode(distro))}
-                    >
-                      <Show when={installingOpencode()}>
-                        <Spinner class="size-4 shrink-0" />
-                      </Show>
-                      {opencodeCheck()?.resolvedPath ? "Update OpenCode" : "Install OpenCode"}
-                    </Button>
-                  </Show>
-                </div>
-              </div>
-              <div class="text-12-regular text-text-weak whitespace-pre-wrap break-words">{opencodeMessage()}</div>
-              <Show when={opencodeCheck()?.matchesDesktop === false ? opencodeCheck() : null}>
-                {(check) => (
-                  <div class="rounded-md border border-border-weak-base px-3 py-3 flex flex-col gap-1">
-                    <div class="text-12-regular text-text-weak">Path: {check().resolvedPath ?? "not found"}</div>
-                    <div class="text-12-regular text-text-weak">
-                      Version: {check().version ?? "unknown"}
-                      <Show when={check().expectedVersion}>
-                        {(expected) => <span>{` · desktop ${expected()}`}</span>}
-                      </Show>
-                    </div>
-                    <div class="text-12-regular text-text-warning-base">
-                      Installed version does not match the desktop app version.
-                    </div>
-                  </div>
-                )}
-              </Show>
-            </div>
-          </Match>
-          </Switch>
-
-          <Show when={activeStep() === "opencode" && allReady() && store.selectedDistro}>
-            <div class="flex items-center justify-end gap-2">
-              <Button variant="ghost" size="large" disabled={store.adding} onClick={() => dialog.close()}>
-                Cancel
-              </Button>
-              <Button variant="primary" size="large" disabled={addDisabled()} onClick={() => void finish()}>
-                {store.adding ? "Adding..." : "Add WSL server"}
-              </Button>
-            </div>
-          </Show>
-        </Show>
-      </Show>
-    </div>
-  )
-}
-
-function requestError(language: ReturnType<typeof useLanguage>, err: unknown) {
-  console.error("WSL servers request failed", err instanceof Error ? (err.stack ?? err.message) : String(err))
-  showToast({
-    variant: "error",
-    title: language.t("common.requestFailed"),
-    description: err instanceof Error ? err.message : String(err),
-  })
-}

packages/app/src/components/server/server-row.tsx

@@ -17,7 +17,6 @@ import type { ServerHealth } from "@/utils/server-health"
 interface ServerRowProps extends ParentProps {
   conn: ServerConnection.Any
   status?: ServerHealth
-  version?: string
   class?: string
   nameClass?: string
   versionClass?: string
@@ -32,8 +31,6 @@ export function ServerRow(props: ServerRowProps) {
   let nameRef: HTMLSpanElement | undefined
   let versionRef: HTMLSpanElement | undefined
   const name = createMemo(() => serverName(props.conn))
-  const isWsl = createMemo(() => props.conn.type === "sidecar" && props.conn.variant === "wsl")
-  const version = createMemo(() => props.version ?? props.status?.version)
 
   const check = () => {
     const nameTruncated = nameRef ? nameRef.scrollWidth > nameRef.clientWidth : false
@@ -44,7 +41,7 @@ export function ServerRow(props: ServerRowProps) {
   createEffect(() => {
     name()
     props.conn.http.url
-    version()
+    props.status?.version
     queueMicrotask(check)
   })
 
@@ -57,11 +54,8 @@ export function ServerRow(props: ServerRowProps) {
   const tooltipValue = () => (
     <span class="flex items-center gap-2">
       <span>{serverName(props.conn, true)}</span>
-      <Show when={isWsl()}>
-        <span class="text-text-invert-weak">WSL</span>
-      </Show>
-      <Show when={version()}>
-        <span class="text-text-invert-weak">v{version()}</span>
+      <Show when={props.status?.version}>
+        <span class="text-text-invert-weak">v{props.status?.version}</span>
       </Show>
     </span>
   )
@@ -82,20 +76,15 @@ export function ServerRow(props: ServerRowProps) {
             <span ref={nameRef} class={`${props.nameClass ?? "truncate"} min-w-0`}>
               {name()}
             </span>
-            <Show when={isWsl()}>
-              <span class="text-11-regular text-text-weak border border-border-weak-base bg-surface-base px-1.5 py-0.5 rounded-md shrink-0">
-                WSL
-              </span>
-            </Show>
             <Show
               when={badge()}
               fallback={
-                <Show when={version()}>
+                <Show when={props.status?.version}>
                   <span
                     ref={versionRef}
                     class={`${props.versionClass ?? "text-text-weak text-14-regular truncate"} min-w-0`}
                   >
-                    v{version()}
+                    v{props.status?.version}
                   </span>
                 </Show>
               }

packages/app/src/components/status-popover-body.tsx

@@ -3,9 +3,9 @@ import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Switch } from "@opencode-ai/ui/switch"
 import { Tabs } from "@opencode-ai/ui/tabs"
-import { showToast } from "@opencode-ai/ui/toast"
 import { useMutation, useQueryClient } from "@tanstack/solid-query"
-import { useLocation, useNavigate } from "@solidjs/router"
+import { showToast } from "@/utils/toast"
+import { useNavigate } from "@solidjs/router"
 import { type Accessor, createEffect, createMemo, For, type JSXElement, onCleanup, Show } from "solid-js"
 import { createStore } from "solid-js/store"
 import { ServerHealthIndicator, ServerRow } from "@/components/server/server-row"
@@ -286,7 +286,7 @@ function ServerStatusList(props: { state: ServerStatusState }) {
   )
 }
 
-export function StatusPopoverBody(props: { shown: Accessor<boolean>; close?: () => void }) {
+export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
   const sync = useSync()
   const servers = useServers()
   const server = useServer()
@@ -294,7 +294,6 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean>; close?: ()
   const dialog = useDialog()
   const language = useLanguage()
   const navigate = useNavigate()
-  const location = useLocation()
 
   const fail = (err: unknown) => {
     showToast({
@@ -375,16 +374,8 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean>; close?: ()
                       aria-disabled={blocked()}
                       onClick={() => {
                         if (blocked()) return
-                        props.close?.()
                         navigate("/")
-                        const activate = () => {
-                          if (location.pathname !== "/") {
-                            setTimeout(activate, 16)
-                            return
-                          }
-                          setTimeout(() => server.setActive(key), 0)
-                        }
-                        setTimeout(activate, 0)
+                        queueMicrotask(() => server.setActive(key))
                       }}
                     >
                       <ServerHealthIndicator health={servers.health[key]} />

packages/app/src/components/status-popover.tsx

@@ -67,7 +67,7 @@ export function StatusPopover() {
             <div class="w-[360px] h-14 rounded-xl bg-background-strong shadow-[var(--shadow-lg-border-base)]" />
           }
         >
-          <Body shown={shown} close={() => setShown(false)} />
+          <Body shown={shown} />
         </Suspense>
       </Show>
     </Popover>

packages/app/src/context/global-sync/child-store.ts

@@ -95,24 +95,6 @@ export function createChildStoreManager(input: {
     })
   }
 
-  function disposeChild(key: DirectoryKey) {
-    const dispose = disposers.get(key)
-    if (!key || !children[key]) return false
-    vcsCache.delete(key)
-    metaCache.delete(key)
-    iconCache.delete(key)
-    lifecycle.delete(key)
-    mcpDirectories.delete(key)
-    mcpToggles.delete(key)
-    disposers.delete(key)
-    delete children[key]
-    input.onDispose(key)
-    if (dispose) {
-      dispose()
-    }
-    return true
-  }
-
   function disposeDirectory(directory: DirectoryKey) {
     const key = directory
     if (
@@ -127,13 +109,20 @@ export function createChildStoreManager(input: {
       return false
     }
 
-    return disposeChild(key)
-  }
-
-  function disposeAll() {
-    for (const directory of Object.keys(children)) {
-      disposeChild(directoryKey(directory))
+    vcsCache.delete(key)
+    metaCache.delete(key)
+    iconCache.delete(key)
+    lifecycle.delete(key)
+    mcpDirectories.delete(key)
+    mcpToggles.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) {
@@ -362,7 +351,6 @@ export function createChildStoreManager(input: {
     mcp: (directory: string) => mcpDirectories.has(directoryKey(directory)),
     disableMcp,
     disposeDirectory,
-    disposeAll,
     runEviction,
     vcsCache,
     metaCache,

packages/app/src/context/platform.tsx

@@ -20,88 +20,6 @@ export type FatalRendererErrorLog = {
   os?: DesktopOS
 }
 
-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 WslOpencodeCheck = {
-  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-distro"; distro: string; startedAt: number }
-  | { kind: "probe-opencode"; distro: string; startedAt: number }
-  | { kind: "install-opencode"; distro: string; startedAt: number }
-
-export type WslServersState = {
-  runtime: WslRuntimeCheck | null
-  installed: WslInstalledDistro[]
-  online: WslOnlineDistro[]
-  distroProbes: Record<string, WslDistroProbe>
-  opencodeChecks: Record<string, WslOpencodeCheck>
-  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>
-  probeDistro(name: string): Promise<void>
-  probeOpencode(name: string): Promise<void>
-  installOpencode(name: string): Promise<void>
-  openTerminal(name: string): Promise<void>
-  addServer(distro: string): Promise<WslServerConfig>
-  removeServer(id: string): Promise<void>
-  startServer(id: string): Promise<void>
-}
-
 export type Platform = {
   /** Platform discriminator */
   platform: PlatformName
@@ -157,8 +75,11 @@ export type Platform = {
   /** Set the default server URL to use on app startup (platform-specific) */
   setDefaultServer?(url: ServerConnection.Key | null): Promise<void> | void
 
-  /** Manage WSL sidecar servers (Electron on Windows only) */
-  wslServers?: WslServersPlatform
+  /** Get the configured WSL integration (desktop only) */
+  getWslEnabled?(): Promise<boolean>
+
+  /** Set the configured WSL integration (desktop only) */
+  setWslEnabled?(config: boolean): Promise<void> | void
 
   /** Get the preferred display backend (desktop only) */
   getDisplayBackend?(): Promise<DisplayBackend | null> | DisplayBackend | null

packages/app/src/context/server-sync.tsx

@@ -397,7 +397,11 @@ export function createServerSyncContext() {
   onCleanup(() => {
     queue.dispose()
   })
-  onCleanup(children.disposeAll)
+  onCleanup(() => {
+    for (const directory of Object.keys(children.children)) {
+      children.disposeDirectory(directoryKey(directory))
+    }
+  })
 
   onMount(() => {
     if (typeof requestAnimationFrame === "function") {

packages/app/src/context/server.tsx

@@ -1,5 +1,5 @@
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import { type Accessor, batch, createEffect, createMemo } from "solid-js"
+import { type Accessor, batch, createMemo } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Persist, persisted } from "@/utils/persist"
 
@@ -151,12 +151,6 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
       if (state.active !== input) setState("active", input)
     }
 
-    createEffect(() => {
-      if (typeof window === "undefined") return
-      window.__OPENCODE__ ??= {}
-      window.__OPENCODE__.activeServer = state.active
-    })
-
     function add(input: ServerConnection.Http) {
       const url_ = normalizeServerUrl(input.http.url)
       if (!url_) return
@@ -193,7 +187,7 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
     )
     const isLocal = createMemo(() => {
       const c = current()
-      return c?.type === "sidecar" || (c?.type === "http" && isLocalHost(c.http.url))
+      return (c?.type === "sidecar" && c.variant === "base") || (c?.type === "http" && isLocalHost(c.http.url))
     })
 
     return {

packages/app/src/context/wsl-servers.tsx

@@ -1,35 +0,0 @@
-import { createSimpleContext } from "@opencode-ai/ui/context"
-import { queryOptions, skipToken, useQuery, useQueryClient } from "@tanstack/solid-query"
-import { createEffect, onCleanup } from "solid-js"
-import type { WslServersPlatform, WslServersState } from "./platform"
-import { usePlatform } from "./platform"
-
-const wslServersQueryKey = ["platform", "wslServers"] as const
-
-export const { use: useWslServers, provider: WslServersProvider } = createSimpleContext({
-  name: "WslServers",
-  init: () => {
-    const platform = usePlatform()
-    const queryClient = useQueryClient()
-    const query = useQuery(() => {
-      const api = platform.wslServers
-      return queryOptions<WslServersState>({
-        queryKey: wslServersQueryKey,
-        queryFn: api ? () => api.getState() : skipToken,
-        staleTime: Number.POSITIVE_INFINITY,
-        gcTime: Number.POSITIVE_INFINITY,
-      })
-    })
-
-    createEffect(() => {
-      const api = platform.wslServers
-      if (!api) return
-      const off = api.subscribe((event) => {
-        queryClient.setQueryData(wslServersQueryKey, event.state)
-      })
-      onCleanup(off)
-    })
-
-    return query
-  },
-})

packages/app/src/index.ts

@@ -2,24 +2,6 @@ export { AppBaseProviders, AppInterface } from "./app"
 export { ACCEPTED_FILE_EXTENSIONS, ACCEPTED_FILE_TYPES, filePickerFilters } from "./constants/file-picker"
 export { useCommand } from "./context/command"
 export { loadLocaleDict, normalizeLocale, type Locale } from "./context/language"
-export { useWslServers } from "./context/wsl-servers"
-export {
-  type DisplayBackend,
-  type FatalRendererErrorLog,
-  type Platform,
-  PlatformProvider,
-  type WslDistroProbe,
-  type WslInstalledDistro,
-  type WslJob,
-  type WslOnlineDistro,
-  type WslOpencodeCheck,
-  type WslRuntimeCheck,
-  type WslServerConfig,
-  type WslServerItem,
-  type WslServerRuntime,
-  type WslServersEvent,
-  type WslServersPlatform,
-  type WslServersState,
-} from "./context/platform"
+export { type DisplayBackend, type FatalRendererErrorLog, type Platform, PlatformProvider } from "./context/platform"
 export { ServerConnection } from "./context/server"
 export { handleNotificationClick } from "./utils/notification-click"

packages/app/src/pages/home.tsx

@@ -993,7 +993,6 @@ function LegacyHome() {
     if (healthy === false) return "bg-icon-critical-base"
     return "bg-border-weak-base"
   })
-  const useWebDirectoryPicker = createMemo(() => server.current?.type === "sidecar" && server.current.variant === "wsl")
 
   function openProject(directory: string) {
     layout.projects.open(directory)
@@ -1012,7 +1011,7 @@ function LegacyHome() {
       }
     }
 
-    if (platform.openDirectoryPickerDialog && server.isLocal() && !useWebDirectoryPicker()) {
+    if (platform.openDirectoryPickerDialog && server.isLocal()) {
       const result = await platform.openDirectoryPickerDialog?.({
         title: language.t("command.project.open"),
         multiple: true,
@@ -1033,7 +1032,7 @@ function LegacyHome() {
         size="large"
         variant="ghost"
         class="mt-4 mx-auto text-14-regular text-text-weak"
-        onClick={() => dialog.show(() => <DialogSelectServer onNavigateHome={() => navigate("/")} />)}
+        onClick={() => dialog.show(() => <DialogSelectServer />)}
       >
         <div
           classList={{

packages/app/src/pages/layout.tsx

@@ -153,7 +153,6 @@ export default function Layout(props: ParentProps) {
   }
   const colorSchemeLabel = (scheme: ColorScheme) => language.t(colorSchemeKey[scheme])
   const currentDir = createMemo(() => route().dir)
-  const useWebDirectoryPicker = createMemo(() => server.current?.type === "sidecar" && server.current.variant === "wsl")
 
   const [state, setState] = createStore({
     autoselect: !initialDirectory && !newDesign(),
@@ -1224,7 +1223,7 @@ export default function Layout(props: ParentProps) {
     const run = ++dialogRun
     void import("@/components/dialog-select-server").then((x) => {
       if (dialogDead || dialogRun !== run) return
-      dialog.show(() => <x.DialogSelectServer onNavigateHome={() => navigate("/")} />)
+      dialog.show(() => <x.DialogSelectServer />)
     })
   }
 
@@ -1480,7 +1479,7 @@ export default function Layout(props: ParentProps) {
       }
     }
 
-    if (platform.openDirectoryPickerDialog && server.isLocal() && !useWebDirectoryPicker()) {
+    if (platform.openDirectoryPickerDialog && server.isLocal()) {
       const result = await platform.openDirectoryPickerDialog?.({
         title: language.t("command.project.open"),
         multiple: true,

packages/app/src/utils/solid-dnd.tsx

@@ -1,6 +1,6 @@
 import { useDragDropContext } from "@thisbeyond/solid-dnd"
 import type { Transformer } from "@thisbeyond/solid-dnd"
-import type { JSXElement } from "solid-js"
+import { createRoot, onCleanup, type JSXElement } from "solid-js"
 
 type DragEvent = { draggable?: { id?: unknown } }
 
@@ -27,16 +27,20 @@ const createAxisConstraint = (axis: "x" | "y", transformerId: string) => (): JSX
   if (!context) return null
   const [, { onDragStart, onDragEnd, addTransformer, removeTransformer }] = context
   const transformer = createTransformer(transformerId, axis)
-  onDragStart((event) => {
-    const id = getDraggableId(event)
-    if (!id) return
-    addTransformer("draggables", id, transformer)
-  })
-  onDragEnd((event) => {
-    const id = getDraggableId(event)
-    if (!id) return
-    removeTransformer("draggables", id, transformer.id)
+  const dispose = createRoot((dispose) => {
+    onDragStart((event) => {
+      const id = getDraggableId(event)
+      if (!id) return
+      addTransformer("draggables", id, transformer)
+    })
+    onDragEnd((event) => {
+      const id = getDraggableId(event)
+      if (!id) return
+      removeTransformer("draggables", id, transformer.id)
+    })
+    return dispose
   })
+  onCleanup(dispose)
   return null
 }
 

packages/core/src/auth-well-known.ts

@@ -1,242 +0,0 @@
-export * as AuthWellKnown from "./auth-well-known"
-
-import path from "path"
-import { Context, Effect, Layer, Option, Schema, SynchronizedRef } from "effect"
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
-import { AppFileSystem } from "./filesystem"
-import { Global } from "./global"
-import { Substitution } from "./substitution"
-
-export class Entry extends Schema.Class<Entry>("AuthWellKnown.Entry")({
-  key: Schema.String,
-  token: Schema.String,
-}) {}
-
-export class FileWriteError extends Schema.TaggedErrorClass<FileWriteError>()("AuthWellKnown.FileWriteError", {
-  operation: Schema.Union([Schema.Literal("migrate"), Schema.Literal("write")]),
-  cause: Schema.Defect,
-}) {}
-
-export class RemoteConfigError extends Schema.TaggedErrorClass<RemoteConfigError>()("AuthWellKnown.RemoteConfigError", {
-  url: Schema.String,
-  status: Schema.Number.pipe(Schema.optional),
-  cause: Schema.Defect.pipe(Schema.optional),
-}) {}
-
-export type Error = FileWriteError | RemoteConfigError
-
-const RemoteConfig = Schema.Struct({
-  url: Schema.String,
-  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-})
-
-export class Metadata extends Schema.Class<Metadata>("AuthWellKnown.Metadata")({
-  auth: Schema.Struct({
-    command: Schema.Array(Schema.String),
-    env: Schema.String,
-  }).pipe(Schema.optional),
-  config: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-  remote_config: RemoteConfig.pipe(Schema.optional),
-}) {}
-
-export type ConfigDocument = {
-  url: string
-  source: string
-  dir: string
-  content: unknown
-}
-
-export interface Interface {
-  readonly all: () => Effect.Effect<Record<string, Entry>, Error>
-  readonly get: (url: string) => Effect.Effect<Entry | undefined, Error>
-  readonly set: (url: string, entry: Entry) => Effect.Effect<void, Error>
-  readonly remove: (url: string) => Effect.Effect<void, Error>
-  readonly metadata: (url: string) => Effect.Effect<Metadata, Error>
-  readonly configs: () => Effect.Effect<ConfigDocument[], Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/AuthWellKnown") {}
-const decodeMetadata = Schema.decodeUnknownEffect(Metadata)
-const decodeRemoteConfig = Schema.decodeUnknownEffect(RemoteConfig)
-
-function loadLegacyAuth(input: {
-  fsys: AppFileSystem.Interface
-  dataDir: string
-  write: (data: Record<string, Entry>) => Effect.Effect<void, Error>
-}) {
-  return Effect.gen(function* () {
-    const decodeLegacy = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))
-    const decodeLegacyCredential = Schema.decodeUnknownOption(
-      Schema.Struct({
-        type: Schema.Literal("wellknown"),
-        key: Schema.String,
-        token: Schema.String,
-      }),
-    )
-    const legacy = Object.fromEntries(
-      Object.entries(
-        Option.getOrElse(
-          decodeLegacy(
-            yield* input.fsys.readJson(path.join(input.dataDir, "auth.json")).pipe(Effect.orElseSucceed(() => null)),
-          ),
-          () => ({}),
-        ),
-      ).flatMap(([url, value]) => {
-        const decoded = Option.getOrUndefined(decodeLegacyCredential(value))
-        return decoded ? [[url.replace(/\/+$/, ""), new Entry({ key: decoded.key, token: decoded.token })]] : []
-      }),
-    )
-    if (Object.keys(legacy).length > 0) yield* input.write(legacy).pipe(Effect.ignore)
-    return legacy
-  })
-}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* AppFileSystem.Service
-    const global = yield* Global.Service
-    const http = yield* HttpClient.HttpClient
-    const substitution = yield* Substitution.Service
-    const file = path.join(global.data, "well-known.json")
-    const decodeEntries = Schema.decodeUnknownOption(Schema.Record(Schema.String, Entry))
-    const normalizeUrl = (url: string) => url.replace(/\/+$/, "")
-
-    const write = (operation: "migrate" | "write", data: Record<string, Entry>) =>
-      fsys.writeJson(file, data, 0o600).pipe(Effect.mapError((cause) => new FileWriteError({ operation, cause })))
-
-    const load: () => Effect.Effect<Record<string, Entry>> = Effect.fnUntraced(function* () {
-      const current = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
-      if (current && typeof current === "object")
-        return Option.getOrElse(decodeEntries(current), () => ({}) as Record<string, Entry>)
-      return yield* loadLegacyAuth({ fsys, dataDir: global.data, write: (data) => write("migrate", data) })
-    })
-
-    const state = SynchronizedRef.makeUnsafe<Record<string, Entry>>(yield* load())
-
-    const metadata = Effect.fn("AuthWellKnown.metadata")(function* (url: string) {
-      const normalized = normalizeUrl(url)
-      const source = `${normalized}/.well-known/opencode`
-      const response = yield* HttpClientRequest.get(source).pipe(
-        HttpClientRequest.acceptJson,
-        http.execute,
-        Effect.mapError((cause) => new RemoteConfigError({ url: source, cause })),
-      )
-      if (response.status < 200 || response.status >= 300) {
-        return yield* new RemoteConfigError({ url: source, status: response.status })
-      }
-      const metadata = yield* response.json.pipe(
-        Effect.flatMap(decodeMetadata),
-        Effect.mapError((cause) => new RemoteConfigError({ url: source, cause })),
-      )
-      return { url: normalized, source, dir: path.dirname(source), metadata }
-    })
-
-    const remote = Effect.fn("AuthWellKnown.remote")(function* (input: { url: string; headers?: Record<string, string> }) {
-      const response = yield* HttpClientRequest.get(input.url).pipe(
-        HttpClientRequest.acceptJson,
-        input.headers ? HttpClientRequest.setHeaders(input.headers) : (request) => request,
-        http.execute,
-        Effect.mapError((cause) => new RemoteConfigError({ url: input.url, cause })),
-      )
-      if (response.status < 200 || response.status >= 300) {
-        return yield* new RemoteConfigError({ url: input.url, status: response.status })
-      }
-      return yield* response.json.pipe(Effect.mapError((cause) => new RemoteConfigError({ url: input.url, cause })))
-    })
-
-    return Service.of({
-      all: Effect.fn("AuthWellKnown.all")(function* () {
-        return yield* SynchronizedRef.get(state)
-      }),
-
-      get: Effect.fn("AuthWellKnown.get")(function* (url) {
-        return (yield* SynchronizedRef.get(state))[normalizeUrl(url)]
-      }),
-
-      set: Effect.fn("AuthWellKnown.set")(function* (url, entry) {
-        yield* SynchronizedRef.updateEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const next = { ...data, [normalizeUrl(url)]: entry }
-            yield* write("write", next)
-            return next
-          }),
-        )
-      }),
-
-      remove: Effect.fn("AuthWellKnown.remove")(function* (url) {
-        yield* SynchronizedRef.updateEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const next = { ...data }
-            delete next[url]
-            delete next[normalizeUrl(url)]
-            yield* write("write", next)
-            return next
-          }),
-        )
-      }),
-
-      metadata: Effect.fn("AuthWellKnown.metadata.public")(function* (url) {
-        return (yield* metadata(url)).metadata
-      }),
-
-      configs: Effect.fn("AuthWellKnown.configs")(function* () {
-        const documents = yield* Effect.all(
-          Object.entries(yield* SynchronizedRef.get(state)).map(([url, entry]) =>
-            Effect.gen(function* () {
-              const configs: ConfigDocument[] = []
-              const response = yield* metadata(url)
-              const env = { [entry.key]: entry.token }
-              if (response.metadata.config) {
-                configs.push({
-                  url: response.url,
-                  source: response.source,
-                  dir: response.dir,
-                  content: response.metadata.config,
-                })
-              }
-              if (response.metadata.remote_config) {
-                const remoteConfig = yield* substitution
-                  .substitute({
-                    text: JSON.stringify(response.metadata.remote_config),
-                    type: "virtual",
-                    dir: response.url,
-                    source: response.source,
-                    env,
-                  })
-                  .pipe(
-                    Effect.flatMap((text) =>
-                      Effect.try({
-                        try: () => JSON.parse(text) as unknown,
-                        catch: (cause) => new RemoteConfigError({ url: response.source, cause }),
-                      }),
-                    ),
-                    Effect.flatMap(decodeRemoteConfig),
-                    Effect.mapError((cause) => new RemoteConfigError({ url: response.source, cause })),
-                  )
-                configs.push({
-                  url: remoteConfig.url,
-                  source: remoteConfig.url,
-                  dir: path.dirname(remoteConfig.url),
-                  content: yield* remote({ url: remoteConfig.url, headers: remoteConfig.headers }),
-                })
-              }
-              return configs
-            }),
-          ),
-          { concurrency: "unbounded" },
-        )
-        return documents.flat()
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Global.defaultLayer),
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provide(Substitution.defaultLayer),
-)

packages/core/src/session.ts

@@ -16,6 +16,7 @@ import { SessionProjector } from "./session/projector"
 import { SessionMessageTable, SessionTable } from "./session/sql"
 import { SessionSchema } from "./session/schema"
 import { AbsolutePath, RelativePath } from "./schema"
+import { AgentV2 } from "./agent"
 
 // get project -> project.locations
 //
@@ -141,14 +142,12 @@ export interface Interface {
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}
 
 function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
-  return new SessionSchema.Info({
+  return SessionSchema.Info.make({
     id: SessionSchema.ID.make(row.id),
     projectID: ProjectV2.ID.make(row.project_id),
-    workspaceID: row.workspace_id ? WorkspaceV2.ID.make(row.workspace_id) : undefined,
     title: row.title,
     parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
-    path: row.path ?? "",
-    agent: row.agent ?? undefined,
+    agent: row.agent ? AgentV2.ID.make(row.agent) : undefined,
     model: row.model
       ? {
           id: ModelV2.ID.make(row.model.id),
@@ -166,6 +165,11 @@ function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
         write: row.tokens_cache_write,
       },
     },
+    location: Location.Ref.make({
+      directory: AbsolutePath.make(row.directory),
+      workspaceID: row.workspace_id ? WorkspaceV2.ID.make(row.workspace_id) : undefined,
+    }),
+    subpath: row.path ? RelativePath.make(row.path) : undefined,
     time: {
       created: DateTime.makeUnsafe(row.time_created),
       updated: DateTime.makeUnsafe(row.time_updated),

packages/core/src/session/schema.ts

@@ -5,9 +5,9 @@ import { Location } from "../location"
 import { ModelV2 } from "../model"
 import { ProjectV2 } from "../project"
 import { RelativePath, optionalOmitUndefined, withStatics } from "../schema"
-import { WorkspaceV2 } from "../workspace"
 import { Identifier } from "../util/identifier"
 import { V2Schema } from "../v2-schema"
+import { AgentV2 } from "../agent"
 
 export const Delivery = Schema.Literals(["immediate", "deferred"]).annotate({
   identifier: "Session.Delivery",
@@ -24,22 +24,12 @@ export const ID = Schema.String.check(Schema.isStartsWith("ses")).pipe(
 )
 export type ID = typeof ID.Type
 
-export const LegacyInfo = Schema.Struct({
+export class Info extends Schema.Class<Info>("SessionV2.Info")({
   id: ID,
-  location: Location.Ref,
-  subpath: RelativePath, // derived from location
-  project: ProjectV2.ID, // derived from location
-})
-export type LegacyInfo = typeof LegacyInfo.Type
-
-export class Info extends Schema.Class<Info>("Session.Info")({
-  id: ID,
-  parentID: optionalOmitUndefined(ID),
+  parentID: ID.pipe(optionalOmitUndefined),
   projectID: ProjectV2.ID,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  path: optionalOmitUndefined(Schema.String),
-  agent: optionalOmitUndefined(Schema.String),
-  model: ModelV2.Ref.pipe(optionalOmitUndefined),
+  agent: AgentV2.ID.pipe(Schema.optional),
+  model: ModelV2.Ref.pipe(Schema.optional),
   cost: Schema.Finite,
   tokens: Schema.Struct({
     input: Schema.Finite,
@@ -53,7 +43,9 @@ export class Info extends Schema.Class<Info>("Session.Info")({
   time: Schema.Struct({
     created: V2Schema.DateTimeUtcFromMillis,
     updated: V2Schema.DateTimeUtcFromMillis,
-    archived: optionalOmitUndefined(V2Schema.DateTimeUtcFromMillis),
+    archived: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
   }),
   title: Schema.String,
+  location: Location.Ref,
+  subpath: RelativePath.pipe(Schema.optional),
 }) {}

packages/core/src/substitution.ts

@@ -1,94 +0,0 @@
-export * as Substitution from "./substitution"
-
-import os from "os"
-import path from "path"
-import { Context, Effect, Layer, Schema } from "effect"
-import { AppFileSystem } from "./filesystem"
-
-type Source =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-export type Input = Source & {
-  text: string
-  missing?: "error" | "empty"
-  env?: Record<string, string | undefined>
-}
-
-export class FileReferenceError extends Schema.TaggedErrorClass<FileReferenceError>()("Substitution.FileReferenceError", {
-  source: Schema.String,
-  token: Schema.String,
-  resolved: Schema.String,
-  cause: Schema.Defect,
-}) {}
-
-export type Error = FileReferenceError
-
-export interface Interface {
-  readonly substitute: (input: Input) => Effect.Effect<string, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Substitution") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    return Service.of({
-      substitute: Effect.fn("Substitution.substitute")(function* (input) {
-        const missing = input.missing ?? "error"
-        const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-          return input.env?.[varName] ?? process.env[varName] ?? ""
-        })
-
-        const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-        if (!fileMatches.length) return text
-
-        const configDir = input.type === "path" ? path.dirname(input.path) : input.dir
-        const configSource = input.type === "path" ? input.path : input.source
-        let out = ""
-        let cursor = 0
-
-        for (const match of fileMatches) {
-          const token = match[0]
-          const index = match.index!
-          out += text.slice(cursor, index)
-
-          const lineStart = text.lastIndexOf("\n", index - 1) + 1
-          const prefix = text.slice(lineStart, index).trimStart()
-          if (prefix.startsWith("//")) {
-            out += token
-            cursor = index + token.length
-            continue
-          }
-
-          const reference = token.replace(/^\{file:/, "").replace(/\}$/, "")
-          const filepath = reference.startsWith("~/") ? path.join(os.homedir(), reference.slice(2)) : reference
-          const resolved = path.isAbsolute(filepath) ? filepath : path.resolve(configDir, filepath)
-          const content = yield* fs.readFileString(resolved).pipe(
-            Effect.catch((cause) => {
-              if (missing === "empty") return Effect.succeed("")
-              return Effect.fail(new FileReferenceError({ source: configSource, token, resolved, cause }))
-            }),
-          )
-
-          out += JSON.stringify(content.trim()).slice(1, -1)
-          cursor = index + token.length
-        }
-
-        out += text.slice(cursor)
-        return out
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))

packages/core/test/auth-well-known.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect } from "bun:test"
-import path from "path"
-import { Effect, Layer } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Global } from "@opencode-ai/core/global"
-import { Substitution } from "@opencode-ai/core/substitution"
-import { AuthWellKnown } from "@opencode-ai/core/auth-well-known"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(Layer.empty)
-
-const unexpectedHttpClient = HttpClient.make((request) => Effect.die(`unexpected http request: ${request.url}`))
-
-const withAuthWellKnown = <A, E, R>(
-  dir: string,
-  effect: Effect.Effect<A, E, R | AuthWellKnown.Service>,
-  client = unexpectedHttpClient,
-) =>
-  effect.pipe(
-    Effect.provide(AuthWellKnown.layer),
-    Effect.provide(AppFileSystem.defaultLayer),
-    Effect.provide(Global.layerWith({ data: dir })),
-    Effect.provide(Layer.succeed(HttpClient.HttpClient, client)),
-    Effect.provide(Substitution.defaultLayer),
-  )
-
-const wellKnownConfigClient = HttpClient.make((request) => {
-  if (request.url === "https://example.com/.well-known/opencode") {
-    return Effect.succeed(
-      HttpClientResponse.fromWeb(
-        request,
-        Response.json({
-          config: { instructions: ["local"] },
-          remote_config: {
-            url: "https://remote.example.com/config",
-            headers: {
-              authorization: "Bearer {env:TEST_TOKEN}",
-            },
-          },
-        }),
-      ),
-    )
-  }
-  if (request.url === "https://remote.example.com/config") {
-    expect(request.headers.authorization).toBe("Bearer secret")
-    return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ model: "remote/model" })))
-  }
-  return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status: 404 })))
-})
-
-describe("AuthWellKnown", () => {
-  it.live("stores well-known credentials", () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      )
-
-      yield* withAuthWellKnown(
-        tmp.path,
-        Effect.gen(function* () {
-          const auth = yield* AuthWellKnown.Service
-          yield* auth.set("https://example.com/", new AuthWellKnown.Entry({ key: "TEST_TOKEN", token: "secret" }))
-        }),
-      )
-
-      expect(yield* Effect.promise(() => Bun.file(path.join(tmp.path, "well-known.json")).json())).toEqual({
-        "https://example.com": {
-          key: "TEST_TOKEN",
-          token: "secret",
-        },
-      })
-    }),
-  )
-
-  it.live("migrates legacy well-known auth records", () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(tmp.path, "auth.json"),
-          JSON.stringify({
-            "https://example.com": {
-              type: "wellknown",
-              key: "TEST_TOKEN",
-              token: "secret",
-            },
-          }),
-        ),
-      )
-
-      const entry = yield* withAuthWellKnown(
-        tmp.path,
-        Effect.gen(function* () {
-          const auth = yield* AuthWellKnown.Service
-          return yield* auth.get("https://example.com/")
-        }),
-      )
-
-      expect(entry).toEqual({
-        key: "TEST_TOKEN",
-        token: "secret",
-      })
-      expect(yield* Effect.promise(() => Bun.file(path.join(tmp.path, "well-known.json")).json())).toEqual({
-        "https://example.com": {
-          key: "TEST_TOKEN",
-          token: "secret",
-        },
-      })
-    }),
-  )
-
-  it.live("loads config documents", () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(tmp.path, "well-known.json"),
-          JSON.stringify({
-            "https://example.com": {
-              key: "TEST_TOKEN",
-              token: "secret",
-            },
-          }),
-        ),
-      )
-
-      const result = yield* withAuthWellKnown(
-        tmp.path,
-        Effect.gen(function* () {
-          const auth = yield* AuthWellKnown.Service
-          return yield* auth.configs()
-        }),
-        wellKnownConfigClient,
-      )
-
-      expect(result).toEqual([
-        {
-          url: "https://example.com",
-          source: "https://example.com/.well-known/opencode",
-          dir: "https://example.com/.well-known",
-          content: { instructions: ["local"] },
-        },
-        {
-          url: "https://remote.example.com/config",
-          source: "https://remote.example.com/config",
-          dir: "https://remote.example.com",
-          content: { model: "remote/model" },
-        },
-      ])
-    }),
-  )
-})

packages/core/test/auth.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { EventV2 } from "@opencode-ai/core/event"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Global } from "@opencode-ai/core/global"
-import { Auth } from "@opencode-ai/core/auth"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(Layer.empty)
-
-const withAuth = <A, E, R>(dir: string, effect: Effect.Effect<A, E, R | Auth.Service>) =>
-  effect.pipe(
-    Effect.provide(Auth.layer),
-    Effect.provide(AppFileSystem.defaultLayer),
-    Effect.provide(Global.layerWith({ data: dir })),
-    Effect.provide(EventV2.defaultLayer),
-  )
-
-describe("Auth", () => {
-  it.live("stores api credentials", () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      )
-
-      const account = yield* withAuth(
-        tmp.path,
-        Effect.gen(function* () {
-          const auth = yield* Auth.Service
-          return yield* auth.create({
-            serviceID: Auth.ServiceID.make("anthropic"),
-            credential: new Auth.ApiKeyCredential({ type: "api", key: "sk-test" }),
-          })
-        }),
-      )
-
-      const active = yield* withAuth(
-        tmp.path,
-        Effect.gen(function* () {
-          const auth = yield* Auth.Service
-          return yield* auth.active(Auth.ServiceID.make("anthropic"))
-        }),
-      )
-
-      if (!account) throw new Error("expected account")
-      expect(active?.id).toBe(account.id)
-      expect(active?.credential).toEqual({ type: "api", key: "sk-test" })
-    }),
-  )
-})

packages/desktop/src/main/apps.ts

@@ -1,8 +1,7 @@
-import { execFile } from "node:child_process"
+import { execFile, execFileSync } from "node:child_process"
 import { access, readFile, readdir } from "node:fs/promises"
 import { dirname, extname, join } from "node:path"
 import util from "node:util"
-import { resolveWslHome, runWslInDistro } from "./wsl"
 
 const execFilePromise = util.promisify(execFile)
 
@@ -22,44 +21,20 @@ export function resolveAppPath(appName: string) {
   return resolveWindowsAppPath(appName)
 }
 
-// Parses `\\wsl$\<distro>\...` and `\\wsl.localhost\<distro>\...` UNC paths that
-// point *into* a WSL distro's rootfs. `wslpath -u` cannot handle these reliably:
-// backslashes get shell-collapsed when passed through `wsl.exe`, turning
-// `\\wsl.localhost\Debian\home\luke` into `/mnt/c/wsl.localhostDebianhomeluke`,
-// which is a valid-looking path that wedges opencode on DrvFs stat calls.
-function parseWslUncPath(value: string): { distro: string; subpath: string } | null {
-  // Normalise separators; both `\\` and `//` prefixes mean UNC.
-  const normalised = value.replace(/\\/g, "/").replace(/^\/+/, "//")
-  const match = /^\/\/(wsl\$|wsl\.localhost)\/([^/]+)(?:\/(.*))?$/i.exec(normalised)
-  if (!match) return null
-  const distro = match[2]
-  const subpath = match[3] ?? ""
-  return { distro, subpath }
-}
-
-export async function wslPath(path: string, mode: "windows" | "linux" | null, distro?: string | null): Promise<string> {
+export function wslPath(path: string, mode: "windows" | "linux" | null): string {
   if (process.platform !== "win32") return path
 
-  // `\\wsl$\<distro>\...` / `\\wsl.localhost\<distro>\...` -> `/<subpath>` in
-  // the target distro. Do the conversion in-process rather than shelling out
-  // to `wslpath -u`, which mangles backslashes via wsl.exe's command-line
-  // joiner. If the requested distro differs from the UNC distro, we still
-  // translate literally — callers are responsible for only picking paths
-  // inside the active distro.
-  if (mode === "linux") {
-    const unc = parseWslUncPath(path)
-    if (unc) return `/${unc.subpath}`
-  }
-
   const flag = mode === "windows" ? "-w" : "-u"
   try {
-    const resolved = path.startsWith("~") ? `${await resolveWslHome(distro)}${path.slice(1)}` : path
-    const input = mode === "linux" ? resolved.replace(/\\/g, "/") : resolved
-    const output = await runWslInDistro(["wslpath", flag, input], distro)
-    if (output.code !== 0) {
-      throw new Error(output.stderr || output.stdout || `wslpath exited with code ${output.code}`)
+    if (path.startsWith("~")) {
+      const suffix = path.slice(1)
+      const cmd = `wslpath ${flag} "$HOME${suffix.replace(/"/g, '\\"')}"`
+      const output = execFileSync("wsl", ["-e", "sh", "-lc", cmd])
+      return output.toString().trim()
     }
-    return output.stdout.trim()
+
+    const output = execFileSync("wsl", ["-e", "wslpath", flag, path])
+    return output.toString().trim()
   } catch (error) {
     throw new Error(`Failed to run wslpath: ${String(error)}`, { cause: error })
   }

packages/desktop/src/main/constants.ts

@@ -6,7 +6,6 @@ export const CHANNEL: Channel = raw === "dev" || raw === "beta" || raw === "prod
 
 export const SETTINGS_STORE = "opencode.settings"
 export const DEFAULT_SERVER_URL_KEY = "defaultServerUrl"
-export const WSL_SERVERS_KEY = "wslServers"
 export const WSL_ENABLED_KEY = "wslEnabled"
 export const PINCH_ZOOM_ENABLED_KEY = "pinchZoomEnabled"
 export const UPDATER_ENABLED = app.isPackaged && CHANNEL !== "dev"

packages/desktop/src/main/index.ts

@@ -9,10 +9,9 @@ import { getCACertificates, setDefaultCACertificates } from "node:tls"
 import type { Event } from "electron"
 import { app, BrowserWindow } from "electron"
 
-import { Deferred, Effect, Fiber } from "effect"
 import contextMenu from "electron-context-menu"
 
-import type { InitStep, ServerReadyData, SqliteMigrationProgress } from "../preload/types"
+import type { InitStep, ServerReadyData, SqliteMigrationProgress, WslConfig } from "../preload/types"
 import { checkAppExists, resolveAppPath, wslPath } from "./apps"
 import { CHANNEL, UPDATER_ENABLED } from "./constants"
 import { registerIpcHandlers, sendDeepLinks, sendMenuCommand, sendSqliteMigrationProgress } from "./ipc"
@@ -21,13 +20,13 @@ import { parseMarkdown } from "./markdown"
 import { createMenu } from "./menu"
 import {
   getDefaultServerUrl,
+  getWslConfig,
   preferAppEnv,
   setDefaultServerUrl,
+  setWslConfig,
   spawnLocalServer,
-  spawnWslSidecar,
   type SidecarListener,
 } from "./server"
-import { checkUpdate, checkForUpdates, installUpdate, setupAutoUpdater } from "./updater"
 import {
   createLoadingWindow,
   createMainWindow,
@@ -36,8 +35,9 @@ import {
   setBackgroundColor,
   setDockIcon,
 } from "./windows"
-import { createWslServersController } from "./wsl-servers"
 import { migrate } from "./migrate"
+import { checkUpdate, checkForUpdates, installUpdate, setupAutoUpdater } from "./updater"
+import { Deferred, Effect, Fiber } from "effect"
 
 const APP_NAMES: Record<string, string> = {
   dev: "OpenCode Dev",
@@ -145,30 +145,6 @@ const main = Effect.gen(function* () {
   logger = initLogging()
   initCrashReporter()
 
-  const wslServers = createWslServersController(
-    app.getVersion(),
-    async (distro) => {
-      logger.log("spawning wsl sidecar", { distro })
-      return spawnWslSidecar(distro, {
-        onLine: (line) => logger.log("wsl sidecar", { distro, stream: line.stream, text: line.text }),
-      })
-    },
-    {
-      log: (message, meta) => logger.log(message, meta),
-      error: (message, meta) => logger.error(message, meta),
-    },
-  )
-  const stopSidecars = async () => {
-    await killSidecar()
-    wslServers.stopAll()
-  }
-  const relaunch = () => {
-    void stopSidecars().finally(() => {
-      app.relaunch()
-      app.exit(0)
-    })
-  }
-
   try {
     setDefaultCACertificates([...new Set([...getCACertificates("default"), ...getCACertificates("system")])])
   } catch (error) {
@@ -214,11 +190,11 @@ const main = Effect.gen(function* () {
   })
 
   app.on("before-quit", () => {
-    void stopSidecars()
+    void killSidecar()
   })
 
   app.on("will-quit", () => {
-    void stopSidecars()
+    void killSidecar()
   })
 
   app.on("child-process-gone", (_event, details) => {
@@ -238,7 +214,7 @@ const main = Effect.gen(function* () {
 
   for (const signal of ["SIGINT", "SIGTERM"] as const) {
     process.on(signal, () => {
-      void stopSidecars().finally(() => app.exit(0))
+      void killSidecar().finally(() => app.exit(0))
     })
   }
 
@@ -247,7 +223,6 @@ const main = Effect.gen(function* () {
 
   registerIpcHandlers({
     killSidecar: () => killSidecar(),
-    relaunch,
     awaitInitialization: Effect.fnUntraced(
       function* (sendStep) {
         sendStep(initStep)
@@ -264,33 +239,22 @@ const main = Effect.gen(function* () {
       },
       (e) => Effect.runPromise(e),
     ),
-    getWslServersState: () => wslServers.getState(),
-    onWslServersEvent: (listener) => wslServers.subscribe(listener),
-    wslServersProbeRuntime: () => wslServers.probeRuntime(),
-    wslServersRefreshDistros: () => wslServers.refreshDistros(),
-    wslServersInstallWsl: () => wslServers.installWsl(),
-    wslServersInstallDistro: (name) => wslServers.installDistro(name),
-    wslServersProbeDistro: (name) => wslServers.probeDistro(name),
-    wslServersProbeOpencode: (name) => wslServers.probeOpencode(name),
-    wslServersInstallOpencode: (name) => wslServers.installOpencode(name),
-    wslServersOpenTerminal: (name) => wslServers.openTerminal(name),
-    wslServersAddServer: (distro) => wslServers.addServer(distro),
-    wslServersRemoveServer: (id) => wslServers.removeServer(id),
-    wslServersStartServer: (id) => wslServers.startServer(id),
     getWindowConfig: () => ({ updaterEnabled: UPDATER_ENABLED }),
     consumeInitialDeepLinks: () => pendingDeepLinks.splice(0),
     getDefaultServerUrl: () => getDefaultServerUrl(),
     setDefaultServerUrl: (url) => setDefaultServerUrl(url),
+    getWslConfig: () => Promise.resolve(getWslConfig()),
+    setWslConfig: (config: WslConfig) => setWslConfig(config),
     getDisplayBackend: async () => null,
     setDisplayBackend: async () => undefined,
     parseMarkdown: async (markdown) => parseMarkdown(markdown),
     checkAppExists: (appName) => checkAppExists(appName),
-    wslPath: async (path, mode, distro) => wslPath(path, mode, distro),
+    wslPath: async (path, mode) => wslPath(path, mode),
     resolveAppPath: async (appName) => resolveAppPath(appName),
     loadingWindowComplete: () => Deferred.doneUnsafe(loadingComplete, Effect.void),
-    runUpdater: async (alertOnFail) => checkForUpdates(alertOnFail, stopSidecars),
+    runUpdater: async (alertOnFail) => checkForUpdates(alertOnFail, killSidecar),
     checkUpdate: async () => checkUpdate(),
-    installUpdate: async () => installUpdate(stopSidecars),
+    installUpdate: async () => installUpdate(killSidecar),
     setBackgroundColor: (color) => setBackgroundColor(color),
     exportDebugLogs: () => exportDebugLogs(),
     recordFatalRendererError: (error) => writeLog("renderer", "fatal renderer error", { ...error }, "error"),
@@ -377,10 +341,6 @@ const main = Effect.gen(function* () {
       password,
     })
 
-    void wslServers
-      .initialize({ defaultServer: getDefaultServerUrl() })
-      .catch((error) => logger.error("wsl server initialization failed", error))
-
     yield* Effect.promise(() => health.wait).pipe(
       Effect.timeout("30 seconds"),
       Effect.catch((e) =>
@@ -419,7 +379,7 @@ const main = Effect.gen(function* () {
         if (win) sendMenuCommand(win, id)
       },
       checkForUpdates: () => {
-        void checkForUpdates(true, stopSidecars)
+        void checkForUpdates(true, killSidecar)
       },
       relaunch: () => {
         void killSidecar().finally(() => {

packages/desktop/src/main/ipc.ts

@@ -10,9 +10,7 @@ import type {
   SqliteMigrationProgress,
   TitlebarTheme,
   WindowConfig,
-  WslServerConfig,
-  WslServersEvent,
-  WslServersState,
+  WslConfig,
 } from "../preload/types"
 import { runDesktopMenuAction } from "./desktop-menu-actions"
 import { getStore } from "./store"
@@ -25,30 +23,18 @@ const pickerFilters = (ext?: string[]) => {
 
 type Deps = {
   killSidecar: () => Promise<void> | void
-  relaunch: () => void
   awaitInitialization: (sendStep: (step: InitStep) => void) => Promise<ServerReadyData>
-  getWslServersState: () => Promise<WslServersState> | WslServersState
-  onWslServersEvent: (listener: (event: WslServersEvent) => void) => () => void
-  wslServersProbeRuntime: () => Promise<void> | void
-  wslServersRefreshDistros: () => Promise<void> | void
-  wslServersInstallWsl: () => Promise<void> | void
-  wslServersInstallDistro: (name: string) => Promise<void> | void
-  wslServersProbeDistro: (name: string) => Promise<void> | void
-  wslServersProbeOpencode: (name: string) => Promise<void> | void
-  wslServersInstallOpencode: (name: string) => Promise<void> | void
-  wslServersOpenTerminal: (name: string) => Promise<void> | void
-  wslServersAddServer: (distro: string) => Promise<WslServerConfig> | WslServerConfig
-  wslServersRemoveServer: (id: string) => Promise<void> | void
-  wslServersStartServer: (id: string) => Promise<void> | void
   getWindowConfig: () => Promise<WindowConfig> | WindowConfig
   consumeInitialDeepLinks: () => Promise<string[]> | string[]
   getDefaultServerUrl: () => Promise<string | null> | string | null
   setDefaultServerUrl: (url: string | null) => Promise<void> | void
+  getWslConfig: () => Promise<WslConfig>
+  setWslConfig: (config: WslConfig) => Promise<void> | void
   getDisplayBackend: () => Promise<string | null>
   setDisplayBackend: (backend: string | null) => Promise<void> | void
   parseMarkdown: (markdown: string) => Promise<string> | string
   checkAppExists: (appName: string) => Promise<boolean> | boolean
-  wslPath: (path: string, mode: "windows" | "linux" | null, distro?: string | null) => Promise<string>
+  wslPath: (path: string, mode: "windows" | "linux" | null) => Promise<string>
   resolveAppPath: (appName: string) => Promise<string | null>
   loadingWindowComplete: () => void
   runUpdater: (alertOnFail: boolean) => Promise<void> | void
@@ -60,89 +46,27 @@ type Deps = {
 }
 
 export function registerIpcHandlers(deps: Deps) {
-  const requireString = (name: string, value: unknown) => {
-    if (typeof value === "string" && value.length > 0) return value
-    throw new Error(`Invalid ${name}`)
-  }
-
-  const wslSubscriptions = new Map<number, () => void>()
-  const unsubscribeWsl = (id: number) => {
-    const off = wslSubscriptions.get(id)
-    if (!off) return
-    off()
-    wslSubscriptions.delete(id)
-  }
-
-  app.once("will-quit", () => {
-    for (const off of wslSubscriptions.values()) off()
-    wslSubscriptions.clear()
-  })
-
   ipcMain.handle("kill-sidecar", () => deps.killSidecar())
   ipcMain.handle("await-initialization", (event: IpcMainInvokeEvent) => {
     const send = (step: InitStep) => event.sender.send("init-step", step)
     return deps.awaitInitialization(send)
   })
-  ipcMain.handle("wsl-servers-subscribe", (event) => {
-    const id = event.sender.id
-    if (wslSubscriptions.has(id)) return
-    wslSubscriptions.set(
-      id,
-      deps.onWslServersEvent((payload) => {
-        if (event.sender.isDestroyed()) {
-          unsubscribeWsl(id)
-          return
-        }
-        event.sender.send("wsl-servers-event", payload)
-      }),
-    )
-    event.sender.once("destroyed", () => unsubscribeWsl(id))
-  })
-  ipcMain.handle("wsl-servers-unsubscribe", (event) => unsubscribeWsl(event.sender.id))
-  ipcMain.handle("wsl-servers-get-state", () => deps.getWslServersState())
-  ipcMain.handle("wsl-servers-probe-runtime", () => deps.wslServersProbeRuntime())
-  ipcMain.handle("wsl-servers-refresh-distros", () => deps.wslServersRefreshDistros())
-  ipcMain.handle("wsl-servers-install-wsl", () => deps.wslServersInstallWsl())
-  ipcMain.handle("wsl-servers-install-distro", (_event: IpcMainInvokeEvent, name: string) =>
-    deps.wslServersInstallDistro(requireString("distro", name)),
-  )
-  ipcMain.handle("wsl-servers-probe-distro", (_event: IpcMainInvokeEvent, name: string) =>
-    deps.wslServersProbeDistro(requireString("distro", name)),
-  )
-  ipcMain.handle("wsl-servers-probe-opencode", (_event: IpcMainInvokeEvent, name: string) =>
-    deps.wslServersProbeOpencode(requireString("distro", name)),
-  )
-  ipcMain.handle("wsl-servers-install-opencode", (_event: IpcMainInvokeEvent, name: string) =>
-    deps.wslServersInstallOpencode(requireString("distro", name)),
-  )
-  ipcMain.handle("wsl-servers-open-terminal", (_event: IpcMainInvokeEvent, name: string) =>
-    deps.wslServersOpenTerminal(requireString("distro", name)),
-  )
-  ipcMain.handle("wsl-servers-add", (_event: IpcMainInvokeEvent, distro: string) =>
-    deps.wslServersAddServer(requireString("distro", distro)),
-  )
-  ipcMain.handle("wsl-servers-remove", (_event: IpcMainInvokeEvent, id: string) =>
-    deps.wslServersRemoveServer(requireString("server id", id)),
-  )
-  ipcMain.handle("wsl-servers-start", (_event: IpcMainInvokeEvent, id: string) =>
-    deps.wslServersStartServer(requireString("server id", id)),
-  )
   ipcMain.handle("get-window-config", () => deps.getWindowConfig())
   ipcMain.handle("consume-initial-deep-links", () => deps.consumeInitialDeepLinks())
   ipcMain.handle("get-default-server-url", () => deps.getDefaultServerUrl())
   ipcMain.handle("set-default-server-url", (_event: IpcMainInvokeEvent, url: string | null) =>
     deps.setDefaultServerUrl(url),
   )
+  ipcMain.handle("get-wsl-config", () => deps.getWslConfig())
+  ipcMain.handle("set-wsl-config", (_event: IpcMainInvokeEvent, config: WslConfig) => deps.setWslConfig(config))
   ipcMain.handle("get-display-backend", () => deps.getDisplayBackend())
   ipcMain.handle("set-display-backend", (_event: IpcMainInvokeEvent, backend: string | null) =>
     deps.setDisplayBackend(backend),
   )
   ipcMain.handle("parse-markdown", (_event: IpcMainInvokeEvent, markdown: string) => deps.parseMarkdown(markdown))
   ipcMain.handle("check-app-exists", (_event: IpcMainInvokeEvent, appName: string) => deps.checkAppExists(appName))
-  ipcMain.handle(
-    "wsl-path",
-    (_event: IpcMainInvokeEvent, path: string, mode: "windows" | "linux" | null, distro?: string | null) =>
-      deps.wslPath(path, mode, distro),
+  ipcMain.handle("wsl-path", (_event: IpcMainInvokeEvent, path: string, mode: "windows" | "linux" | null) =>
+    deps.wslPath(path, mode),
   )
   ipcMain.handle("resolve-app-path", (_event: IpcMainInvokeEvent, appName: string) => deps.resolveAppPath(appName))
   ipcMain.on("loading-window-complete", () => deps.loadingWindowComplete())
@@ -267,7 +191,8 @@ export function registerIpcHandlers(deps: Deps) {
   })
 
   ipcMain.on("relaunch", () => {
-    deps.relaunch()
+    app.relaunch()
+    app.exit(0)
   })
 
   ipcMain.handle("get-zoom-factor", (event: IpcMainInvokeEvent) => event.sender.getZoomFactor())

packages/desktop/src/main/server.ts

@@ -1,15 +1,13 @@
-import { spawn } from "node:child_process"
-import { randomUUID } from "node:crypto"
-import { createServer } from "node:net"
 import { dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
 import { app, utilityProcess } from "electron"
 import type { Details } from "electron"
-import type { SqliteMigrationProgress } from "../preload/types"
-import { DEFAULT_SERVER_URL_KEY } from "./constants"
+import { DEFAULT_SERVER_URL_KEY, WSL_ENABLED_KEY } from "./constants"
 import { getUserShell, loadShellEnv } from "./shell-env"
 import { getStore } from "./store"
-import { type WslCommandLine, resolveWslOpencode, shellEscape, wslArgs } from "./wsl"
+import type { SqliteMigrationProgress } from "../preload/types"
+
+export type WslConfig = { enabled: boolean }
 
 export type HealthCheck = { wait: Promise<void> }
 
@@ -48,6 +46,15 @@ export function setDefaultServerUrl(url: string | null) {
   getStore().delete(DEFAULT_SERVER_URL_KEY)
 }
 
+export function getWslConfig(): WslConfig {
+  const value = getStore().get(WSL_ENABLED_KEY)
+  return { enabled: typeof value === "boolean" ? value : false }
+}
+
+export function setWslConfig(config: WslConfig) {
+  getStore().set(WSL_ENABLED_KEY, config.enabled)
+}
+
 export function preferAppEnv(userDataPath: string) {
   const shell = process.platform === "win32" ? null : getUserShell()
   Object.assign(process.env, {
@@ -194,133 +201,6 @@ export async function spawnLocalServer(
   }
 }
 
-export type WslSidecar = {
-  listener: { stop: () => void; onExit: (cb: (code: number | null, signal: NodeJS.Signals | null) => void) => void }
-  url: string
-  username: string | null
-  password: string
-}
-
-export async function spawnWslSidecar(
-  distro: string,
-  opts: { onLine?: (line: WslCommandLine) => void; healthTimeoutMs?: number } = {},
-): Promise<WslSidecar> {
-  // Do not pass --user here: the sidecar should inherit the distro's
-  // default user so config, auth, git, ssh, and file ownership match the
-  // user's normal WSL environment. If that default user is root, WSL will
-  // choose root itself.
-  const opencode = await resolveWslOpencode(distro)
-  if (!opencode) throw new Error(`OpenCode is not installed in ${distro}`)
-
-  const port = await allocatePort()
-  const password = randomUUID()
-  const username = "opencode"
-  const logLevel = app.isPackaged ? "WARN" : "INFO"
-
-  const script = [
-    "set -euo pipefail",
-    // wsl.exe inherits the Windows-side cwd (e.g. C:\Users\Lukem) and maps it
-    // to the distro as /mnt/c/Users/Lukem — a DrvFs/9p path. opencode's
-    // instance middleware falls back to `process.cwd()` when a request
-    // arrives without a `directory=` query or `x-opencode-directory` header
-    // (see opencode server.ts InstanceMiddleware), and then calls
-    // `realpathSync(process.cwd())` synchronously on the main thread. A
-    // statx against a 9p path can wedge the whole event loop in kernel
-    // uninterruptible sleep, freezing the accept loop. Move cwd to the
-    // user's native Linux home so the fallback can't land on DrvFs.
-    'cd "$HOME" || cd /',
-    // wsl.exe by default splices the Windows %PATH% into the distro's $PATH
-    // via the interop layer (every `/mnt/c/Program Files/...` entry). Anything
-    // the sidecar spawns — PTY login shells, plugin helpers, etc. — then
-    // inherits it, which means `which pwsh.exe` resolves to the Windows
-    // PowerShell binary and bash-l profiles that end with
-    //   eval "$(oh-my-posh init bash)"   (or similar)
-    // silently run Windows pwsh for prompt rendering, whose banner
-    // ("Loading personal and system profiles took Xms.") then shows up in
-    // opencode's terminal pane. We want a clean, Linux-only environment in
-    // the sidecar, so filter every /mnt/* segment out of PATH and clear
-    // WSLENV so no further Windows vars leak in. Users who really need
-    // Windows binaries in the sidecar can invoke them by absolute path.
-    'PATH=$(awk -v RS=: -v ORS=: \'$0 !~ /^\\/mnt\\//\' <<<"$PATH" | sed "s/:$//")',
-    "export PATH",
-    "export WSLENV=",
-    // WSL sidecars often target /mnt/* worktrees. Keep the desktop-only
-    // watcher/discovery features off there because DrvFs/9p stalls can wedge
-    // the server process after it starts listening.
-    "export OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER=true",
-    "export OPENCODE_CLIENT=desktop",
-    `export OPENCODE_SERVER_USERNAME=${shellEscape(username)}`,
-    `export OPENCODE_SERVER_PASSWORD=${shellEscape(password)}`,
-    'export XDG_STATE_HOME="$HOME/.local/state"',
-    `exec ${shellEscape(opencode)} --print-logs --log-level ${logLevel} serve --hostname 0.0.0.0 --port ${port}`,
-  ].join("\n")
-
-  const child = spawn("wsl", wslArgs(["bash", "-se"], distro), {
-    stdio: ["pipe", "pipe", "pipe"],
-    windowsHide: true,
-  })
-  child.stdin.end(script)
-
-  let settled = false
-  const recentOutput: string[] = []
-  const emit = (line: WslCommandLine) => {
-    if (settled || !line.text.trim()) return
-    recentOutput.push(`[${line.stream}] ${line.text}`)
-    if (recentOutput.length > 12) recentOutput.shift()
-    opts.onLine?.(line)
-  }
-
-  forwardLines(child.stdout, "stdout", emit)
-  forwardLines(child.stderr, "stderr", emit)
-
-  const exit = new Promise<never>((_, reject) => {
-    child.once("error", reject)
-    child.once("exit", (code, signal) => {
-      reject(new Error(startupFailure(code, signal, recentOutput)))
-    })
-  })
-
-  const url = `http://127.0.0.1:${port}`
-  const healthPromise = (async () => {
-    while (true) {
-      await new Promise((resolve) => setTimeout(resolve, 100))
-      if (await checkHealth(url, password)) return
-    }
-  })()
-
-  const timeoutMs = opts.healthTimeoutMs ?? 30_000
-  const timeout = new Promise<never>((_, reject) => {
-    const id = setTimeout(
-      () => reject(new Error(`Sidecar for ${distro} health check timed out after ${timeoutMs}ms`)),
-      timeoutMs,
-    )
-    void healthPromise.finally(() => clearTimeout(id))
-  })
-
-  try {
-    await Promise.race([healthPromise, exit, timeout])
-  } catch (error) {
-    child.kill()
-    throw error
-  } finally {
-    settled = true
-  }
-
-  return {
-    listener: {
-      stop() {
-        child.kill()
-      },
-      onExit(cb) {
-        child.once("exit", cb)
-      },
-    },
-    url,
-    username,
-    password,
-  }
-}
-
 export async function checkHealth(url: string, password?: string | null): Promise<boolean> {
   let healthUrl: URL
   try {
@@ -347,46 +227,6 @@ export async function checkHealth(url: string, password?: string | null): Promis
   }
 }
 
-function allocatePort() {
-  return new Promise<number>((resolve, reject) => {
-    const server = createServer()
-    server.on("error", reject)
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address()
-      if (typeof address !== "object" || !address) {
-        server.close()
-        reject(new Error("Failed to get port"))
-        return
-      }
-      const port = address.port
-      server.close(() => resolve(port))
-    })
-  })
-}
-
-function forwardLines(
-  stream: NodeJS.ReadableStream,
-  source: WslCommandLine["stream"],
-  onLine: (line: WslCommandLine) => void,
-) {
-  let pending = ""
-  stream.setEncoding("utf8")
-  stream.on("data", (chunk: string) => {
-    pending += chunk
-    const lines = pending.split(/\r?\n/g)
-    pending = lines.pop() ?? ""
-    for (const line of lines) onLine({ stream: source, text: line })
-  })
-  stream.on("end", () => {
-    if (pending) onLine({ stream: source, text: pending })
-  })
-}
-
-function startupFailure(code: number | null, signal: NodeJS.Signals | null, recentOutput: string[]) {
-  const suffix = recentOutput.length ? `\n${recentOutput.join("\n")}` : ""
-  return `WSL server exited before becoming healthy (code=${code ?? "null"} signal=${signal ?? "null"})${suffix}`
-}
-
 function createSidecarEnv(): Record<string, string> {
   const env = Object.fromEntries(
     Object.entries(process.env).flatMap(([key, value]) => (value === undefined ? [] : [[key, String(value)]])),

packages/desktop/src/main/wsl-servers.ts

@@ -1,447 +0,0 @@
-import type {
-  WslDistroProbe,
-  WslInstalledDistro,
-  WslJob,
-  WslOnlineDistro,
-  WslOpencodeCheck,
-  WslRuntimeCheck,
-  WslServerConfig,
-  WslServerItem,
-  WslServerRuntime,
-  WslServersEvent,
-  WslServersState,
-} from "../preload/types"
-import { WSL_SERVERS_KEY } from "./constants"
-import { getStore } from "./store"
-import {
-  installWslDistro,
-  installWslOpencode,
-  installWslRuntimeElevated,
-  listInstalledWslDistros,
-  listOnlineWslDistros,
-  openWslTerminal,
-  probeWslDistro,
-  probeWslRuntime,
-  readWslCommandVersion,
-  resolveWslOpencode,
-  summarize,
-  upgradeWslOpencode,
-  wslNeedsRestart,
-} from "./wsl"
-
-type RunningSidecar = {
-  listener: { stop: () => void; onExit: (cb: (code: number | null, signal: NodeJS.Signals | null) => void) => void }
-  url: string
-  username: string | null
-  password: string
-}
-
-type SpawnSidecar = (distro: string) => Promise<RunningSidecar>
-
-type ControllerLogger = {
-  log: (message: string, meta?: unknown) => void
-  error: (message: string, meta?: unknown) => void
-}
-
-export type WslServersController = ReturnType<typeof createWslServersController>
-
-export function wslServerIdForDistro(distro: string) {
-  return `wsl:${distro}`
-}
-
-export function createWslServersController(appVersion: string, spawnSidecar: SpawnSidecar, logger?: ControllerLogger) {
-  let state: WslServersState = initialState()
-  const listeners = new Set<(event: WslServersEvent) => void>()
-  const sidecars = new Map<string, RunningSidecar>()
-  const startAttempts = new Map<string, number>()
-  let jobAbort: AbortController | undefined
-
-  const emit = () => {
-    for (const listener of listeners) listener({ type: "state", state })
-  }
-
-  const setState = (next: Partial<WslServersState>) => {
-    state = { ...state, ...next }
-    emit()
-  }
-
-  const persistServers = (servers: WslServerConfig[]) => {
-    getStore().set(WSL_SERVERS_KEY, { servers })
-  }
-
-  const updateServer = (id: string, update: (item: WslServerItem) => WslServerItem) => {
-    const next = state.servers.map((item) => (item.config.id === id ? update(item) : item))
-    setState({ servers: next })
-  }
-
-  const beginJob = (job: WslJob): AbortController => {
-    jobAbort?.abort()
-    const abort = new AbortController()
-    jobAbort = abort
-    setState({ job })
-    return abort
-  }
-
-  const endJob = (abort: AbortController) => {
-    if (jobAbort !== abort) return
-    jobAbort = undefined
-    setState({ job: null })
-  }
-
-  const refreshFromStore = () => {
-    const persisted = readPersistedServers()
-    const items: WslServerItem[] = persisted.map((config) => {
-      const existing = state.servers.find((item) => item.config.id === config.id)
-      return {
-        config,
-        runtime: existing?.runtime ?? { kind: "stopped" },
-      }
-    })
-    setState({ servers: items })
-  }
-
-  const setRuntime = (id: string, runtime: WslServerRuntime) => {
-    updateServer(id, (item) => ({ ...item, runtime }))
-  }
-
-  const setOpencodeCheck = (distro: string, check: WslOpencodeCheck) => {
-    setState({
-      opencodeChecks: {
-        ...state.opencodeChecks,
-        [distro]: check,
-      },
-    })
-  }
-
-  const refreshOpencodeCheck = async (distro: string, opts?: { signal?: AbortSignal }) => {
-    const resolved = await resolveWslOpencode(distro, opts)
-    const version = resolved ? await readWslCommandVersion(resolved, distro, opts) : null
-    setOpencodeCheck(distro, opencodeCheck(distro, resolved, version, appVersion))
-  }
-
-  const refreshDistroLists = async (opts: { signal?: AbortSignal }) => {
-    const [installed, online] = await Promise.all([
-      listInstalledWslDistros(opts),
-      listOnlineWslDistros(opts),
-    ])
-    return { installed, online }
-  }
-
-  const nextStartAttempt = (id: string) => {
-    const next = (startAttempts.get(id) ?? 0) + 1
-    startAttempts.set(id, next)
-    return next
-  }
-
-  const invalidateStartAttempt = (id: string) => {
-    startAttempts.set(id, (startAttempts.get(id) ?? 0) + 1)
-  }
-
-  const isCurrentStartAttempt = (id: string, attempt: number) => {
-    return startAttempts.get(id) === attempt && state.servers.some((item) => item.config.id === id)
-  }
-
-  const startServer = async (id: string) => {
-    const item = state.servers.find((x) => x.config.id === id)
-    if (!item) return
-    const attempt = nextStartAttempt(id)
-    await stopServerInternal(id)
-    if (!isCurrentStartAttempt(id, attempt)) return
-    setRuntime(id, { kind: "starting" })
-    logger?.log("wsl sidecar starting", { id, distro: item.config.distro })
-    try {
-      const sidecar = await spawnSidecar(item.config.distro)
-      if (!isCurrentStartAttempt(id, attempt)) {
-        try {
-          sidecar.listener.stop()
-        } catch {
-          // ignore stop errors for stale sidecars
-        }
-        return
-      }
-      sidecars.set(id, sidecar)
-      setRuntime(id, {
-        kind: "ready",
-        url: sidecar.url,
-        username: sidecar.username,
-        password: sidecar.password,
-      })
-      sidecar.listener.onExit((code, signal) => {
-        if (sidecars.get(id) !== sidecar) return
-        sidecars.delete(id)
-        const message = startupFailure(code, signal)
-        setRuntime(id, { kind: "failed", message })
-        logger?.error("wsl sidecar exited", { id, distro: item.config.distro, code, signal })
-      })
-      void refreshOpencodeCheck(item.config.distro).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error)
-        logger?.error("wsl opencode check failed", { id, distro: item.config.distro, message })
-      })
-      logger?.log("wsl sidecar ready", { id, distro: item.config.distro, url: sidecar.url })
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      if (!isCurrentStartAttempt(id, attempt)) return
-      setRuntime(id, { kind: "failed", message })
-      // Without this, an Ubuntu-style silent failure leaves no trace in
-      // main.log — the controller captures the message in its state but
-      // nothing surfaces unless the user opens the WSL servers dialog.
-      logger?.error("wsl sidecar failed to start", { id, distro: item.config.distro, message })
-    }
-  }
-
-  const stopServerInternal = async (id: string) => {
-    const existing = sidecars.get(id)
-    if (!existing) return
-    sidecars.delete(id)
-    try {
-      existing.listener.stop()
-    } catch {
-      // ignore stop errors
-    }
-  }
-
-  const runJob = async <T>(job: WslJob, runner: (abort: AbortController) => Promise<T>) => {
-    const abort = beginJob(job)
-    try {
-      const value = await runner(abort)
-      endJob(abort)
-      return value
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        endJob(abort)
-        return undefined
-      }
-      const err = error instanceof Error ? error : new Error(String(error))
-      endJob(abort)
-      throw err
-    }
-  }
-
-  return {
-    getState() {
-      return state
-    },
-    subscribe(listener: (event: WslServersEvent) => void) {
-      listeners.add(listener)
-      return () => listeners.delete(listener)
-    },
-
-    async initialize(opts?: { defaultServer?: string | null }) {
-      refreshFromStore()
-      if (opts?.defaultServer?.startsWith("wsl:")) void startServer(opts.defaultServer)
-    },
-
-    async probeRuntime() {
-      await runJob({ kind: "runtime", startedAt: Date.now() }, async (abort) => {
-        const runtime = await probeWslRuntime({ signal: abort.signal })
-        setState({
-          runtime,
-          pendingRestart: state.pendingRestart && !runtime.available ? state.pendingRestart : false,
-        })
-      })
-    },
-
-    async refreshDistros() {
-      await runJob({ kind: "distros", startedAt: Date.now() }, async (abort) => {
-        setState(await refreshDistroLists({ signal: abort.signal }))
-      })
-    },
-
-    async installWsl() {
-      await runJob({ kind: "install-wsl", startedAt: Date.now() }, async (abort) => {
-        const result = await installWslRuntimeElevated({ signal: abort.signal })
-        if (result.code !== 0) {
-          const message = summarize(result.stderr || result.stdout) || "WSL installation failed"
-          throw new Error(message)
-        }
-        const pendingRestart = wslNeedsRestart(result)
-        setState({ pendingRestart })
-        if (!pendingRestart) {
-          const runtime = await probeWslRuntime({ signal: abort.signal })
-          setState({ runtime })
-        }
-      })
-    },
-
-    async installDistro(name: string) {
-      await runJob({ kind: "install-distro", distro: name, startedAt: Date.now() }, async (abort) => {
-        const result = await installWslDistro(name, { signal: abort.signal })
-        if (result.code !== 0) {
-          const message = summarize(result.stderr || result.stdout) || `Failed to install distro: ${name}`
-          throw new Error(message)
-        }
-        const distros = await refreshDistroLists({ signal: abort.signal })
-        const probe = await probeWslDistro(name, { signal: abort.signal })
-        setState({
-          ...distros,
-          distroProbes: { ...state.distroProbes, [name]: probe },
-        })
-      })
-    },
-
-    async probeDistro(name: string) {
-      await runJob({ kind: "probe-distro", distro: name, startedAt: Date.now() }, async (abort) => {
-        const probe = await probeWslDistro(name, { signal: abort.signal })
-        setState({ distroProbes: { ...state.distroProbes, [name]: probe } })
-      })
-    },
-
-    async probeOpencode(name: string) {
-      await runJob({ kind: "probe-opencode", distro: name, startedAt: Date.now() }, async (abort) => {
-        await refreshOpencodeCheck(name, { signal: abort.signal })
-      })
-    },
-
-    async installOpencode(name: string) {
-      await runJob({ kind: "install-opencode", distro: name, startedAt: Date.now() }, async (abort) => {
-        const resolved = await resolveWslOpencode(name, { signal: abort.signal })
-        const existingVersion = resolved
-          ? await readWslCommandVersion(resolved, name, { signal: abort.signal })
-          : null
-        const result =
-          resolved && existingVersion
-            ? await upgradeWslOpencode(appVersion, resolved, name, { signal: abort.signal })
-            : await installWslOpencode(appVersion, name, { signal: abort.signal })
-        if (result.code !== 0) {
-          throw new Error(summarize(result.stderr || result.stdout) || "OpenCode installation failed")
-        }
-        await refreshOpencodeCheck(name, { signal: abort.signal })
-      })
-    },
-
-    async openTerminal(name: string) {
-      await openWslTerminal(name)
-    },
-
-    async addServer(distro: string): Promise<WslServerConfig> {
-      const id = wslServerIdForDistro(distro)
-      if (state.servers.some((item) => item.config.id === id)) {
-        throw new Error(`${distro} is already added`)
-      }
-      const config: WslServerConfig = {
-        id,
-        distro,
-      }
-      persistServers([...readPersistedServers(), config])
-      setState({
-        servers: [...state.servers, { config, runtime: { kind: "starting" } }],
-      })
-      void startServer(id)
-      return config
-    },
-
-    async removeServer(id: string) {
-      invalidateStartAttempt(id)
-      await stopServerInternal(id)
-      const remaining = readPersistedServers().filter((item) => item.id !== id)
-      persistServers(remaining)
-      setState({ servers: state.servers.filter((item) => item.config.id !== id) })
-    },
-
-    startServer,
-
-    stopAll() {
-      for (const item of state.servers) invalidateStartAttempt(item.config.id)
-      for (const existing of sidecars.values()) {
-        try {
-          existing.listener.stop()
-        } catch {
-          // ignore
-        }
-      }
-      sidecars.clear()
-    },
-  }
-}
-
-function initialState(): WslServersState {
-  return {
-    runtime: null,
-    installed: [],
-    online: [],
-    distroProbes: {},
-    opencodeChecks: {},
-    pendingRestart: false,
-    servers: [],
-    job: null,
-  }
-}
-
-function readPersistedServers(): WslServerConfig[] {
-  const store = getStore()
-  const existing = store.get(WSL_SERVERS_KEY)
-  if (existing && typeof existing === "object") {
-    const record = existing as { servers?: unknown }
-    const list = Array.isArray(record.servers) ? record.servers : []
-    return list.flatMap(normalizePersistedServer)
-  }
-  return []
-}
-
-function normalizePersistedServer(value: unknown): WslServerConfig[] {
-  if (!value || typeof value !== "object") return []
-  const record = value as Record<string, unknown>
-  const distro = typeof record.distro === "string" && record.distro.length > 0 ? record.distro : null
-  if (!distro) return []
-  const id = typeof record.id === "string" && record.id.length > 0 ? record.id : wslServerIdForDistro(distro)
-  return [
-    {
-      id,
-      distro,
-    },
-  ]
-}
-
-function opencodeCheck(
-  distro: string,
-  resolvedPath: string | null,
-  version: string | null,
-  expectedVersion: string,
-): WslOpencodeCheck {
-  if (!resolvedPath) {
-    return {
-      distro,
-      resolvedPath: null,
-      version: null,
-      expectedVersion,
-      matchesDesktop: null,
-      error: "opencode is not installed in this distro",
-    }
-  }
-  if (!version) {
-    return {
-      distro,
-      resolvedPath,
-      version: null,
-      expectedVersion,
-      matchesDesktop: null,
-      error: "opencode is installed but could not run",
-    }
-  }
-  return {
-    distro,
-    resolvedPath,
-    version,
-    expectedVersion,
-    matchesDesktop: version === expectedVersion,
-    error: null,
-  }
-}
-
-function startupFailure(code: number | null, signal: NodeJS.Signals | null) {
-  return `WSL server exited after startup (code=${code ?? "null"} signal=${signal ?? "null"})`
-}
-
-// Re-export types used by callers
-export type {
-  WslInstalledDistro,
-  WslOnlineDistro,
-  WslRuntimeCheck,
-  WslDistroProbe,
-  WslOpencodeCheck,
-  WslServerConfig,
-  WslServerItem,
-  WslServerRuntime,
-  WslServersEvent,
-  WslServersState,
-}

packages/desktop/src/main/wsl.ts

@@ -1,421 +0,0 @@
-import { spawn } from "node:child_process"
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-import * as pty from "@lydell/node-pty"
-import type { WslDistroProbe, WslInstalledDistro, WslOnlineDistro, WslRuntimeCheck } from "../preload/types"
-
-export type WslCommandLine = {
-  stream: "stdout" | "stderr"
-  text: string
-}
-
-export type WslCommandResult = {
-  code: number | null
-  signal: NodeJS.Signals | null
-  stdout: string
-  stderr: string
-}
-
-export type RunWslOptions = {
-  signal?: AbortSignal
-  /**
-   * Ceiling on how long we wait for the child process to exit. When the
-   * LXSS service or a specific distro wedges (e.g. Ubuntu-24.04 with a
-   * pending first-run prompt), `wsl.exe` never returns and any command
-   * that doesn't specify a timeout hangs the entire startup flow. Default
-   * is 20s — enough for slow cold-starts, short enough to fail fast on
-   * a wedge. Callers can override for longer-running jobs.
-   */
-  timeoutMs?: number
-}
-
-const DEFAULT_WSL_TIMEOUT_MS = 20_000
-const DEFAULT_WSL_INSTALL_TIMEOUT_MS = 15 * 60_000
-
-export function wslArgs(args: string[], distro?: string | null, user?: string | null) {
-  return [...(distro ? ["-d", distro] : []), ...(user ? ["--user", user] : []), "--", ...args]
-}
-
-export function runWsl(args: string[], opts: RunWslOptions = {}) {
-  return runCommand("wsl", args, opts)
-}
-
-function runPowerShell(command: string, opts: RunWslOptions = {}) {
-  return runCommand(
-    "powershell.exe",
-    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", command],
-    opts,
-  )
-}
-
-function runCommand(command: string, args: string[], opts: RunWslOptions = {}) {
-  return new Promise<WslCommandResult>((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-      signal: opts.signal,
-    })
-
-    // Guard every wsl.exe invocation with a timeout. When the distro or
-    // the LXSS service is wedged (Ubuntu first-run state, Windows update
-    // pending, etc.) wsl.exe produces no output and never exits; without
-    // this the whole sidecar spawn flow stalls the app forever.
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_WSL_TIMEOUT_MS
-    const timeoutId = setTimeout(() => {
-      try {
-        child.kill()
-      } catch {
-        /* ignore */
-      }
-      reject(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs}ms`))
-    }, timeoutMs)
-
-    let stdout = ""
-    let stderr = ""
-    const stdoutDecoder = createOutputDecoder()
-    const stderrDecoder = createOutputDecoder()
-
-    const append = (stream: WslCommandLine["stream"], chunk: string) => {
-      if (!chunk) return
-      if (stream === "stdout") {
-        stdout += chunk
-        return
-      }
-      stderr += chunk
-    }
-
-    child.stdout.on("data", (chunk: Buffer) => {
-      append("stdout", stdoutDecoder.decode(chunk))
-    })
-    child.stdout.on("end", () => {
-      append("stdout", stdoutDecoder.flush())
-    })
-
-    child.stderr.on("data", (chunk: Buffer) => {
-      append("stderr", stderrDecoder.decode(chunk))
-    })
-    child.stderr.on("end", () => {
-      append("stderr", stderrDecoder.flush())
-    })
-
-    child.once("error", (error) => {
-      clearTimeout(timeoutId)
-      reject(error)
-    })
-    child.once("close", (code, signal) => {
-      clearTimeout(timeoutId)
-      resolve({ code, signal, stdout, stderr })
-    })
-  })
-}
-
-function runInteractiveCommand(command: string, args: string[], opts: RunWslOptions = {}, defaultTimeoutMs: number) {
-  return new Promise<WslCommandResult>((resolve, reject) => {
-    const child = pty.spawn(command, args, {
-      name: "xterm-color",
-      cols: 80,
-      rows: 24,
-      cwd: process.cwd(),
-      env: process.env,
-      useConpty: true,
-    })
-
-    let settled = false
-    let stdout = ""
-
-    const cleanup = () => {
-      clearTimeout(timeoutId)
-      abortCleanup?.()
-    }
-
-    const timeoutMs = opts.timeoutMs ?? defaultTimeoutMs
-    const timeoutId = setTimeout(() => {
-      try {
-        child.kill()
-      } catch {
-        /* ignore */
-      }
-      if (settled) return
-      settled = true
-      cleanup()
-      reject(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs}ms`))
-    }, timeoutMs)
-
-    const abortHandler = () => {
-      try {
-        child.kill()
-      } catch {
-        /* ignore */
-      }
-      if (settled) return
-      settled = true
-      cleanup()
-      reject(new DOMException("Aborted", "AbortError"))
-    }
-    const abortCleanup = opts.signal
-      ? (() => {
-          opts.signal?.addEventListener("abort", abortHandler, { once: true })
-          return () => opts.signal?.removeEventListener("abort", abortHandler)
-        })()
-      : undefined
-
-    child.onData((data: string) => {
-      stdout += data
-    })
-    child.onExit((event: { exitCode: number }) => {
-      if (settled) return
-      settled = true
-      cleanup()
-      resolve({ code: event.exitCode, signal: null, stdout, stderr: "" })
-    })
-  })
-}
-
-function createOutputDecoder() {
-  let decoder: TextDecoder | undefined
-  return {
-    decode(chunk: Buffer) {
-      decoder ??= new TextDecoder(detectOutputEncoding(chunk))
-      return decoder.decode(chunk, { stream: true })
-    },
-    flush() {
-      return decoder?.decode() ?? ""
-    },
-  }
-}
-
-function detectOutputEncoding(chunk: Uint8Array) {
-  if (chunk[0] === 0xff && chunk[1] === 0xfe) return "utf-16le"
-  const pairs = Math.floor(chunk.length / 2)
-  if (pairs < 2) return "utf-8"
-  const oddZeroes = Array.from({ length: pairs }).filter((_, index) => chunk[index * 2 + 1] === 0).length
-  const evenZeroes = Array.from({ length: pairs }).filter((_, index) => chunk[index * 2] === 0).length
-  return oddZeroes >= Math.ceil(pairs / 3) && evenZeroes * 2 <= oddZeroes ? "utf-16le" : "utf-8"
-}
-
-export function runWslInDistro(args: string[], distro?: string | null, opts?: RunWslOptions) {
-  return runWsl(wslArgs(args, distro), opts)
-}
-
-export function runWslSh(script: string, distro?: string | null, opts?: RunWslOptions) {
-  return runWslInDistro(["sh", "-lc", script], distro, opts)
-}
-
-export async function probeWslRuntime(opts?: RunWslOptions): Promise<WslRuntimeCheck> {
-  const version = await runWsl(["--version"], opts).catch((error) => ({
-    code: 1,
-    signal: null,
-    stdout: "",
-    stderr: error instanceof Error ? error.message : String(error),
-  }))
-
-  if (version.code !== 0) {
-    return {
-      available: false,
-      version: null,
-      error: summarize(version.stderr || version.stdout) || "WSL is unavailable",
-    }
-  }
-
-  return {
-    available: true,
-    version: firstLine(version.stdout),
-    error: null,
-  }
-}
-
-export async function listInstalledWslDistros(opts?: RunWslOptions) {
-  const result = await runWsl(["--list", "--verbose"], opts)
-  if (result.code !== 0) {
-    throw new Error(summarize(result.stderr || result.stdout) || "Failed to list installed WSL distros")
-  }
-  return parseInstalledDistros(result.stdout)
-}
-
-export async function listOnlineWslDistros(opts?: RunWslOptions) {
-  const result = await runWsl(["--list", "--online"], opts)
-  if (result.code !== 0) {
-    throw new Error(summarize(result.stderr || result.stdout) || "Failed to list online WSL distros")
-  }
-  return parseOnlineDistros(result.stdout)
-}
-
-export async function installWslRuntimeElevated(opts?: RunWslOptions) {
-  const script = [
-    "$ErrorActionPreference = 'Stop'",
-    "$process = Start-Process -FilePath 'wsl.exe' -Verb RunAs -ArgumentList @('--install','--no-distribution') -Wait -PassThru",
-    "if ($null -ne $process.ExitCode) { exit $process.ExitCode }",
-  ].join("; ")
-  return runPowerShell(script, withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS))
-}
-
-export async function installWslDistro(name: string, opts?: RunWslOptions) {
-  return runInteractiveCommand(
-    resolveSystem32Command("wsl.exe"),
-    ["--install", "-d", name, "--web-download", "--no-launch"],
-    withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS),
-    DEFAULT_WSL_INSTALL_TIMEOUT_MS,
-  )
-}
-
-export async function installWslOpencode(version: string, distro: string, opts?: RunWslOptions) {
-  return runInteractiveCommand(
-    resolveSystem32Command("wsl.exe"),
-    wslArgs(["bash", "-lc", `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`], distro),
-    withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS),
-    DEFAULT_WSL_INSTALL_TIMEOUT_MS,
-  )
-}
-
-export function wslNeedsRestart(result: WslCommandResult) {
-  return /restart|reboot/i.test(`${result.stdout}\n${result.stderr}`)
-}
-
-export async function probeWslDistro(name: string, opts?: RunWslOptions): Promise<WslDistroProbe> {
-  const executable = await runWslInDistro(["/bin/true"], name, opts).catch((error) => ({
-    code: 1,
-    signal: null,
-    stdout: "",
-    stderr: error instanceof Error ? error.message : String(error),
-  }))
-  if (executable.code !== 0) {
-    return {
-      name,
-      canExecute: false,
-      hasBash: false,
-      hasCurl: false,
-      error: summarize(executable.stderr || executable.stdout) || "Cannot execute commands in distro",
-    }
-  }
-
-  const [bash, curl] = await Promise.all([
-    runWslSh("command -v bash >/dev/null && printf yes || printf no", name, opts),
-    runWslSh("command -v curl >/dev/null && printf yes || printf no", name, opts),
-  ])
-
-  return {
-    name,
-    canExecute: true,
-    hasBash: bash.code === 0 && summarize(bash.stdout) === "yes",
-    hasCurl: curl.code === 0 && summarize(curl.stdout) === "yes",
-    error: null,
-  }
-}
-
-export async function resolveWslHome(distro?: string | null, opts?: RunWslOptions) {
-  return firstLine((await runWslSh('printf "%s\\n" "$HOME"', distro, opts)).stdout) ?? "/"
-}
-
-export async function resolveWslOpencode(distro: string, opts?: RunWslOptions) {
-  const command = firstLine((await runWslSh("command -v opencode 2>/dev/null | grep -v '^/mnt/' | head -n 1 || true", distro, opts)).stdout)
-  if (command) return command
-
-  for (const candidate of [
-    'if [ -x "${XDG_BIN_DIR:-$HOME/.local/bin}/opencode" ]; then printf "%s\\n" "${XDG_BIN_DIR:-$HOME/.local/bin}/opencode"; fi',
-    'if [ -x "$HOME/bin/opencode" ]; then printf "%s\\n" "$HOME/bin/opencode"; fi',
-    'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
-    'if [ -x "/usr/local/bin/opencode" ]; then printf "%s\\n" "/usr/local/bin/opencode"; fi',
-  ]) {
-    const resolved = firstLine((await runWslSh(candidate, distro, opts)).stdout)
-    if (resolved) return resolved
-  }
-
-  return null
-}
-
-export async function readWslCommandVersion(command: string, distro: string, opts?: RunWslOptions) {
-  const result = await runWslSh(`${shellEscape(command)} --version 2>/dev/null || true`, distro, opts)
-  return firstLine(result.stdout)
-}
-
-export async function upgradeWslOpencode(target: string, command: string, distro: string, opts?: RunWslOptions) {
-  return runInteractiveCommand(
-    resolveSystem32Command("wsl.exe"),
-    wslArgs(["bash", "-lc", `${shellEscape(command)} upgrade ${shellEscape(target)}`], distro, "root"),
-    withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS),
-    DEFAULT_WSL_INSTALL_TIMEOUT_MS,
-  )
-}
-
-export function openWslTerminal(distro?: string | null) {
-  if (distro && !/^[a-zA-Z0-9_.-]+$/.test(distro)) {
-    return Promise.reject(new Error("Invalid distro name"))
-  }
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn("cmd.exe", ["/c", "start", "", "wsl", ...(distro ? ["-d", distro] : [])], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-    })
-    child.once("error", reject)
-    child.once("spawn", () => {
-      child.unref()
-      resolve()
-    })
-  })
-}
-
-function parseInstalledDistros(output: string) {
-  return output.split(/\r?\n/g).flatMap((line) => {
-    const trimmed = line.trim()
-    if (!trimmed) return []
-    const match = line.match(/^\s*(\*)?\s*(.*?)\s{2,}\S+\s+(\d+)\s*$/)
-    if (!match) return []
-    const [, marker, name, version] = match
-    if (!name || /^name$/i.test(name)) return []
-    return [
-      {
-        name: name.trim(),
-        version: Number.isNaN(Number.parseInt(version, 10)) ? null : Number.parseInt(version, 10),
-        isDefault: marker === "*",
-      } satisfies WslInstalledDistro,
-    ]
-  })
-}
-
-function parseOnlineDistros(output: string) {
-  return output.split(/\r?\n/g).flatMap((line) => {
-    const trimmed = line.trim()
-    if (!trimmed) return []
-    const match = trimmed.match(/^([A-Za-z0-9._-]+)\s{2,}(.+)$/)
-    if (!match) return []
-    const [, name, label] = match
-    if (/^name$/i.test(name)) return []
-    return [{ name, label: label.trim() } satisfies WslOnlineDistro]
-  })
-}
-
-function firstLine(value: string) {
-  return (
-    value
-      .split(/\r?\n/g)
-      .map((line) => line.trim())
-      .find(Boolean) ?? null
-  )
-}
-
-export function summarize(value: string) {
-  return value
-    .split(/\r?\n/g)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join("\n")
-}
-
-export function shellEscape(value: string) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`
-}
-
-function resolveSystem32Command(command: string) {
-  const root = process.env.SystemRoot ?? process.env.windir
-  if (!root) return command
-  const resolved = join(root, "System32", command)
-  return existsSync(resolved) ? resolved : command
-}
-
-function withTimeout(opts: RunWslOptions | undefined, timeoutMs: number): RunWslOptions {
-  return {
-    ...opts,
-    timeoutMs: opts?.timeoutMs ?? timeoutMs,
-  }
-}

packages/desktop/src/preload/index.ts

@@ -1,5 +1,5 @@
 import { contextBridge, ipcRenderer } from "electron"
-import type { ElectronAPI, InitStep, SqliteMigrationProgress, WslServersEvent } from "./types"
+import type { ElectronAPI, InitStep, SqliteMigrationProgress } from "./types"
 
 const api: ElectronAPI = {
   killSidecar: () => ipcRenderer.invoke("kill-sidecar"),
@@ -11,38 +11,17 @@ const api: ElectronAPI = {
       ipcRenderer.removeListener("init-step", handler)
     })
   },
-  wslServers: {
-    getState: () => ipcRenderer.invoke("wsl-servers-get-state"),
-    subscribe: (cb) => {
-      const handler = (_: unknown, event: WslServersEvent) => cb(event)
-      ipcRenderer.on("wsl-servers-event", handler)
-      void ipcRenderer.invoke("wsl-servers-subscribe")
-      return () => {
-        ipcRenderer.removeListener("wsl-servers-event", handler)
-        void ipcRenderer.invoke("wsl-servers-unsubscribe")
-      }
-    },
-    probeRuntime: () => ipcRenderer.invoke("wsl-servers-probe-runtime"),
-    refreshDistros: () => ipcRenderer.invoke("wsl-servers-refresh-distros"),
-    installWsl: () => ipcRenderer.invoke("wsl-servers-install-wsl"),
-    installDistro: (name) => ipcRenderer.invoke("wsl-servers-install-distro", name),
-    probeDistro: (name) => ipcRenderer.invoke("wsl-servers-probe-distro", name),
-    probeOpencode: (name) => ipcRenderer.invoke("wsl-servers-probe-opencode", name),
-    installOpencode: (name) => ipcRenderer.invoke("wsl-servers-install-opencode", name),
-    openTerminal: (name) => ipcRenderer.invoke("wsl-servers-open-terminal", name),
-    addServer: (distro) => ipcRenderer.invoke("wsl-servers-add", distro),
-    removeServer: (id) => ipcRenderer.invoke("wsl-servers-remove", id),
-    startServer: (id) => ipcRenderer.invoke("wsl-servers-start", id),
-  },
   getWindowConfig: () => ipcRenderer.invoke("get-window-config"),
   consumeInitialDeepLinks: () => ipcRenderer.invoke("consume-initial-deep-links"),
   getDefaultServerUrl: () => ipcRenderer.invoke("get-default-server-url"),
   setDefaultServerUrl: (url) => ipcRenderer.invoke("set-default-server-url", url),
+  getWslConfig: () => ipcRenderer.invoke("get-wsl-config"),
+  setWslConfig: (config) => ipcRenderer.invoke("set-wsl-config", config),
   getDisplayBackend: () => ipcRenderer.invoke("get-display-backend"),
   setDisplayBackend: (backend) => ipcRenderer.invoke("set-display-backend", backend),
   parseMarkdownCommand: (markdown) => ipcRenderer.invoke("parse-markdown", markdown),
   checkAppExists: (appName) => ipcRenderer.invoke("check-app-exists", appName),
-  wslPath: (path, mode, distro) => ipcRenderer.invoke("wsl-path", path, mode, distro),
+  wslPath: (path, mode) => ipcRenderer.invoke("wsl-path", path, mode),
   resolveAppPath: (appName) => ipcRenderer.invoke("resolve-app-path", appName),
   storeGet: (name, key) => ipcRenderer.invoke("store-get", name, key),
   storeSet: (name, key, value) => ipcRenderer.invoke("store-set", name, key, value),

packages/desktop/src/preload/types.ts

@@ -10,87 +10,7 @@ export type ServerReadyData = {
 
 export type SqliteMigrationProgress = { type: "InProgress"; value: number } | { type: "Done" }
 
-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 WslOpencodeCheck = {
-  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-distro"; distro: string; startedAt: number }
-  | { kind: "probe-opencode"; distro: string; startedAt: number }
-  | { kind: "install-opencode"; distro: string; startedAt: number }
-
-export type WslServersState = {
-  runtime: WslRuntimeCheck | null
-  installed: WslInstalledDistro[]
-  online: WslOnlineDistro[]
-  distroProbes: Record<string, WslDistroProbe>
-  opencodeChecks: Record<string, WslOpencodeCheck>
-  pendingRestart: boolean
-  servers: WslServerItem[]
-  job: WslJob | null
-}
-export type WslServersEvent = { type: "state"; state: WslServersState }
-
-export type WslServersAPI = {
-  getState: () => Promise<WslServersState>
-  subscribe: (cb: (event: WslServersEvent) => void) => () => void
-  probeRuntime: () => Promise<void>
-  refreshDistros: () => Promise<void>
-  installWsl: () => Promise<void>
-  installDistro: (name: string) => Promise<void>
-  probeDistro: (name: string) => Promise<void>
-  probeOpencode: (name: string) => Promise<void>
-  installOpencode: (name: string) => Promise<void>
-  openTerminal: (name: string) => Promise<void>
-  addServer: (distro: string) => Promise<WslServerConfig>
-  removeServer: (id: string) => Promise<void>
-  startServer: (id: string) => Promise<void>
-}
+export type WslConfig = { enabled: boolean }
 
 export type LinuxDisplayBackend = "wayland" | "auto"
 export type TitlebarTheme = {
@@ -112,16 +32,17 @@ export type ElectronAPI = {
   killSidecar: () => Promise<void>
   installCli: () => Promise<string>
   awaitInitialization: (onStep: (step: InitStep) => void) => Promise<ServerReadyData>
-  wslServers: WslServersAPI
   getWindowConfig: () => Promise<WindowConfig>
   consumeInitialDeepLinks: () => Promise<string[]>
   getDefaultServerUrl: () => Promise<string | null>
   setDefaultServerUrl: (url: string | null) => Promise<void>
+  getWslConfig: () => Promise<WslConfig>
+  setWslConfig: (config: WslConfig) => Promise<void>
   getDisplayBackend: () => Promise<LinuxDisplayBackend | null>
   setDisplayBackend: (backend: LinuxDisplayBackend | null) => Promise<void>
   parseMarkdownCommand: (markdown: string) => Promise<string>
   checkAppExists: (appName: string) => Promise<boolean>
-  wslPath: (path: string, mode: "windows" | "linux" | null, distro?: string | null) => Promise<string>
+  wslPath: (path: string, mode: "windows" | "linux" | null) => Promise<string>
   resolveAppPath: (appName: string) => Promise<string | null>
   storeGet: (name: string, key: string) => Promise<string | null>
   storeSet: (name: string, key: string, value: string) => Promise<void>

packages/desktop/src/renderer/env.d.ts

@@ -5,7 +5,6 @@ declare global {
     api: ElectronAPI
     __OPENCODE__?: {
       deepLinks?: string[]
-      activeServer?: string
     }
   }
 }

packages/desktop/src/renderer/index.tsx

@@ -13,18 +13,16 @@ import {
   PlatformProvider,
   ServerConnection,
   useCommand,
-  useWslServers,
 } from "@opencode-ai/app"
 import * as Sentry from "@sentry/solid"
 import type { AsyncStorage } from "@solid-primitives/storage"
 import { MemoryRouter } from "@solidjs/router"
-import { createEffect, createMemo, createResource, onCleanup, onMount, Show } from "solid-js"
+import { createEffect, createResource, onCleanup, onMount, Show } from "solid-js"
 import { render } from "solid-js/web"
 import pkg from "../../package.json"
 import { initI18n, t } from "./i18n"
 import { resetZoom, setPinchZoomEnabled, webviewZoom, zoomIn, zoomOut } from "./webview-zoom"
 import "./styles.css"
-import { Splash } from "@opencode-ai/ui/logo"
 import { useTheme } from "@opencode-ai/ui/theme"
 
 const root = document.getElementById("root")
@@ -81,26 +79,25 @@ const createPlatform = (): Platform => {
     return undefined
   })()
 
-  const activeWslDistro = () => {
-    const key = window.__OPENCODE__?.activeServer
-    if (!key || !key.startsWith("wsl:")) return undefined
-    return key.slice("wsl:".length)
+  const isWslEnabled = async () => {
+    if (os !== "windows") return false
+    return window.api
+      .getWslConfig()
+      .then((config) => config.enabled)
+      .catch(() => false)
   }
 
   const wslHome = async () => {
-    const distro = activeWslDistro()
-    if (!distro) return undefined
-    return window.api.wslPath("~", "windows", distro)
+    if (!(await isWslEnabled())) return undefined
+    return window.api.wslPath("~", "windows").catch(() => undefined)
   }
 
-  const handleWslPicker = async <T extends string | string[] | null>(result: T): Promise<T> => {
-    const distro = activeWslDistro()
-    if (!result || !distro) return result
-    const convert = (path: string) => window.api.wslPath(path, "linux", distro)
+  const handleWslPicker = async <T extends string | string[]>(result: T | null): Promise<T | null> => {
+    if (!result || !(await isWslEnabled())) return result
     if (Array.isArray(result)) {
-      return (await Promise.all(result.map(convert))) as T
+      return Promise.all(result.map((path) => window.api.wslPath(path, "linux").catch(() => path))) as any
     }
-    return (await convert(result)) as T
+    return window.api.wslPath(result, "linux").catch(() => result) as any
   }
 
   const runDesktopMenuAction: Platform["runDesktopMenuAction"] = (action) => {
@@ -146,8 +143,6 @@ const createPlatform = (): Platform => {
     }
   })()
 
-  const wslServersApi = os === "windows" ? window.api.wslServers : undefined
-
   return {
     platform: "desktop",
     os,
@@ -188,8 +183,10 @@ const createPlatform = (): Platform => {
       if (os === "windows") {
         const resolvedApp = app ? await window.api.resolveAppPath(app).catch(() => null) : null
         const resolvedPath = await (async () => {
-          const distro = activeWslDistro()
-          if (distro) return window.api.wslPath(path, "windows", distro)
+          if (await isWslEnabled()) {
+            const converted = await window.api.wslPath(path, "windows").catch(() => null)
+            if (converted) return converted
+          }
           return path
         })()
         return window.api.openPath(resolvedPath, resolvedApp ?? undefined)
@@ -244,7 +241,16 @@ const createPlatform = (): Platform => {
       }
     },
 
-    fetch,
+    fetch: (input, init) => {
+      if (input instanceof Request) return fetch(input)
+      return fetch(input, init)
+    },
+
+    getWslEnabled: () => isWslEnabled(),
+
+    setWslEnabled: async (enabled) => {
+      await window.api.setWslConfig({ enabled })
+    },
 
     getDefaultServer: async () => {
       const url = await window.api.getDefaultServerUrl().catch(() => null)
@@ -256,8 +262,6 @@ const createPlatform = (): Platform => {
       await window.api.setDefaultServerUrl(url)
     },
 
-    wslServers: wslServersApi,
-
     getDisplayBackend: async () => {
       return window.api.getDisplayBackend().catch(() => null)
     },
@@ -299,6 +303,7 @@ listenForDeepLinks()
 
 render(() => {
   const platform = createPlatform()
+  const [windowConfig] = createResource(() => window.api.getWindowConfig().catch(() => ({ updaterEnabled: false })))
   const loadLocale = async () => {
     const current = await platform.storage?.("opencode.global.dat").getItem("language")
     const legacy = current ? undefined : await platform.storage?.().getItem("language.v1")
@@ -313,11 +318,32 @@ render(() => {
 
   const [windowCount] = createResource(() => window.api.getWindowCount())
 
+  // Fetch sidecar credentials (available immediately, before health check)
   const [sidecar] = createResource(() => window.api.awaitInitialization(() => undefined))
 
-  const [defaultServer] = createResource(() => platform.getDefaultServer?.())
+  const [defaultServer] = createResource(() =>
+    platform.getDefaultServer?.().then((url) => {
+      if (url) return ServerConnection.key({ type: "http", http: { url } })
+    }),
+  )
   const [locale] = createResource(loadLocale)
 
+  const servers = () => {
+    const data = sidecar()
+    if (!data) return []
+    const server: ServerConnection.Sidecar = {
+      displayName: "Local Server",
+      type: "sidecar",
+      variant: "base",
+      http: {
+        url: data.url,
+        username: data.username ?? undefined,
+        password: data.password ?? undefined,
+      },
+    }
+    return [server] as ServerConnection.Any[]
+  }
+
   function handleClick(e: MouseEvent) {
     const link = (e.target as HTMLElement).closest("a.external-link") as HTMLAnchorElement | null
     if (link?.href) {
@@ -344,73 +370,6 @@ render(() => {
     return null
   }
 
-  function App() {
-    const wslServers = useWslServers()
-    const splash = (
-      <div class="h-dvh w-screen flex flex-col items-center justify-center bg-background-base">
-        <Splash class="w-16 h-20 opacity-50 animate-pulse" />
-      </div>
-    )
-
-    const ready = createMemo(
-      () =>
-        !defaultServer.loading &&
-        !sidecar.loading &&
-        !windowCount.loading &&
-        !locale.loading,
-    )
-    const servers = createMemo(() => {
-      const data = sidecar()
-      const list: ServerConnection.Any[] = []
-      if (data) {
-        list.push({
-          displayName: "Local Server",
-          type: "sidecar",
-          variant: "base",
-          http: {
-            url: data.url,
-            username: data.username ?? undefined,
-            password: data.password ?? undefined,
-          },
-        })
-      }
-      for (const item of wslServers.data?.servers ?? []) {
-        const runtime = item.runtime
-        if (runtime.kind !== "ready") continue
-        list.push({
-          displayName: item.config.distro,
-          type: "sidecar",
-          variant: "wsl",
-          distro: item.config.distro,
-          http: {
-            url: runtime.url,
-            username: runtime.username ?? undefined,
-            password: runtime.password ?? undefined,
-          },
-        })
-      }
-      return list
-    })
-    const effectiveDefaultServer = createMemo(() => {
-      const key = defaultServer.latest ?? ServerConnection.Key.make("sidecar")
-      if (!key.startsWith("wsl:")) return key
-      const item = wslServers.data?.servers.find((item) => item.config.id === key)
-      if (item?.runtime.kind === "ready") return key
-      return ServerConnection.Key.make("sidecar")
-    })
-    if (!ready()) return splash
-
-    return (
-      <Show when={effectiveDefaultServer()} keyed>
-        {(key) => (
-          <AppInterface defaultServer={key} servers={servers()} router={MemoryRouter}>
-            <Inner />
-          </AppInterface>
-        )}
-      </Show>
-    )
-  }
-
   onMount(() => {
     document.addEventListener("click", handleClick)
     onCleanup(() => {
@@ -421,7 +380,27 @@ render(() => {
   return (
     <PlatformProvider value={platform}>
       <AppBaseProviders locale={locale.latest}>
-        <App />
+        <Show
+          when={
+            !defaultServer.loading &&
+            !sidecar.loading &&
+            !windowConfig.loading &&
+            !windowCount.loading &&
+            !locale.loading
+          }
+        >
+          {(_) => {
+            return (
+              <AppInterface
+                defaultServer={defaultServer.latest ?? ServerConnection.Key.make("sidecar")}
+                servers={servers()}
+                router={MemoryRouter}
+              >
+                <Inner />
+              </AppInterface>
+            )
+          }}
+        </Show>
       </AppBaseProviders>
     </PlatformProvider>
   )

packages/opencode/src/cli/cmd/providers.ts

@@ -1,5 +1,4 @@
 import { Auth } from "../../auth"
-import { AuthWellKnown } from "@opencode-ai/core/auth-well-known"
 import { cmd } from "./cmd"
 import { CliError, effectCmd, fail } from "../effect-cmd"
 import { UI } from "../ui"
@@ -253,7 +252,6 @@ export const ProvidersListCommand = effectCmd({
   instance: false,
   handler: Effect.fn("Cli.providers.list")(function* (_args) {
     const authSvc = yield* Auth.Service
-    const authWellKnown = yield* AuthWellKnown.Service
     const modelsDev = yield* ModelsDev.Service
 
     UI.empty()
@@ -261,8 +259,7 @@ export const ProvidersListCommand = effectCmd({
     const homedir = os.homedir()
     const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
     yield* Prompt.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
-    const results = Object.entries(yield* Effect.orDie(authSvc.all())).filter(([, result]) => result.type !== "wellknown")
-    const wellKnownResults = Object.entries(yield* Effect.orDie(authWellKnown.all()))
+    const results = Object.entries(yield* Effect.orDie(authSvc.all()))
     const database = yield* modelsDev.get()
 
     for (const [providerID, result] of results) {
@@ -270,11 +267,7 @@ export const ProvidersListCommand = effectCmd({
       yield* Prompt.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
     }
 
-    for (const [url] of wellKnownResults) {
-      yield* Prompt.log.info(`${url} ${UI.Style.TEXT_DIM}wellknown`)
-    }
-
-    yield* Prompt.outro(`${results.length + wellKnownResults.length} credentials`)
+    yield* Prompt.outro(`${results.length} credentials`)
 
     const activeEnvVars: Array<{ provider: string; envVar: string }> = []
 
@@ -323,19 +316,19 @@ export const ProvidersLoginCommand = effectCmd({
       }),
   handler: Effect.fn("Cli.providers.login")(function* (args) {
     const authSvc = yield* Auth.Service
-    const authWellKnown = yield* AuthWellKnown.Service
 
     UI.empty()
     yield* Prompt.intro("Add credential")
     if (args.url) {
       const url = args.url.replace(/\/+$/, "")
-      const wellknown = yield* authWellKnown.metadata(url).pipe(
-        Effect.mapError((error) => new CliError({ message: `Failed to load auth provider metadata from ${url}: ${errorMessage(error)}` })),
-      )
-      if (!wellknown.auth) return yield* fail(`Auth provider metadata from ${url} is missing auth configuration`)
+      const wellknown = (yield* cliTry(`Failed to load auth provider metadata from ${url}: `, () =>
+        fetch(`${url}/.well-known/opencode`).then((x) => x.json()),
+      )) as {
+        auth: { command: string[]; env: string }
+      }
       yield* Prompt.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
       const abort = new AbortController()
-      const proc = Process.spawn([...wellknown.auth.command], { stdout: "pipe", stderr: "inherit", abort: abort.signal })
+      const proc = Process.spawn(wellknown.auth.command, { stdout: "pipe", stderr: "inherit", abort: abort.signal })
       if (!proc.stdout) {
         yield* Prompt.log.error("Failed")
         yield* Prompt.outro("Done")
@@ -349,7 +342,7 @@ export const ProvidersLoginCommand = effectCmd({
         yield* Prompt.outro("Done")
         return
       }
-      yield* Effect.orDie(authWellKnown.set(url, new AuthWellKnown.Entry({ key: wellknown.auth.env, token: token.trim() })))
+      yield* Effect.orDie(authSvc.set(url, { type: "wellknown", key: wellknown.auth.env, token: token.trim() }))
       yield* Prompt.log.success("Logged into " + url)
       yield* Prompt.outro("Done")
       return
@@ -499,20 +492,10 @@ export const ProvidersLogoutCommand = effectCmd({
   instance: false,
   handler: Effect.fn("Cli.providers.logout")(function* (_args) {
     const authSvc = yield* Auth.Service
-    const authWellKnown = yield* AuthWellKnown.Service
     const modelsDev = yield* ModelsDev.Service
 
     UI.empty()
-    const credentials = [
-      ...Object.entries(yield* Effect.orDie(authSvc.all()))
-        .filter(([, value]) => value.type !== "wellknown")
-        .map(([key, value]) => ({ key, type: value.type, auth: "provider" as const })),
-      ...Object.keys(yield* Effect.orDie(authWellKnown.all())).map((key) => ({
-        key,
-        type: "wellknown" as const,
-        auth: "wellknown" as const,
-      })),
-    ]
+    const credentials: Array<[string, Auth.Info]> = Object.entries(yield* Effect.orDie(authSvc.all()))
     yield* Prompt.intro("Remove credential")
     if (credentials.length === 0) {
       yield* Prompt.log.error("No credentials found")
@@ -521,15 +504,12 @@ export const ProvidersLogoutCommand = effectCmd({
     const database = yield* modelsDev.get()
     const selected = yield* Prompt.select({
       message: "Select provider",
-      options: credentials.map((item, index) => ({
-        label: (database[item.key]?.name || item.key) + UI.Style.TEXT_DIM + " (" + item.type + ")",
-        value: index,
+      options: credentials.map(([key, value]) => ({
+        label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
+        value: key,
       })),
     })
-    const credential = credentials[yield* promptValue(selected)]
-    if (!credential) return
-    if (credential.auth === "wellknown") yield* Effect.orDie(authWellKnown.remove(credential.key))
-    else yield* Effect.orDie(authSvc.remove(credential.key))
+    yield* Effect.orDie(authSvc.remove(yield* promptValue(selected)))
     yield* Prompt.outro("Logout successful")
   }),
 })

packages/opencode/src/cli/cmd/serve.ts

@@ -1,42 +1,24 @@
 import { Effect } from "effect"
 import { Server } from "../../server/server"
-import { ServerDiscovery } from "@/cli/server-discovery"
 import { effectCmd } from "../effect-cmd"
 import { withNetworkOptions, resolveNetworkOptions } from "../network"
 import { Flag } from "@opencode-ai/core/flag/flag"
 
 export const ServeCommand = effectCmd({
   command: "serve",
-  builder: (yargs) =>
-    withNetworkOptions(yargs).option("discoverable", {
-      type: "boolean",
-      describe: "write this server to the local discovery file for default TUI startup",
-      default: false,
-    }),
+  builder: (yargs) => withNetworkOptions(yargs),
   describe: "starts a headless opencode server",
   // Server loads instances per-request via x-opencode-directory header — no
   // need for an ambient project InstanceContext at startup.
   instance: false,
-  handler: (args) =>
-    Effect.gen(function* () {
-      if (!Flag.OPENCODE_SERVER_PASSWORD) {
-        console.log("Warning: OPENCODE_SERVER_PASSWORD is not set; server is unsecured.")
-      }
-      const opts = yield* resolveNetworkOptions(args)
-      const server = yield* Effect.promise(() => Server.listen(opts))
-      const discovery = args.discoverable ? yield* ServerDiscovery.Service : undefined
-      if (discovery) {
-        yield* discovery.write(server.url)
-        process.on("exit", ServerDiscovery.removeSync)
-      }
-      console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
+  handler: Effect.fn("Cli.serve")(function* (args) {
+    if (!Flag.OPENCODE_SERVER_PASSWORD) {
+      console.log("Warning: OPENCODE_SERVER_PASSWORD is not set; server is unsecured.")
+    }
+    const opts = yield* resolveNetworkOptions(args)
+    const server = yield* Effect.promise(() => Server.listen(opts))
+    console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
 
-      yield* Effect.never.pipe(
-        Effect.ensuring(
-          discovery
-            ? discovery.remove().pipe(Effect.ensuring(Effect.sync(() => process.off("exit", ServerDiscovery.removeSync))))
-            : Effect.void,
-        ),
-      )
-    }).pipe(Effect.provide(ServerDiscovery.defaultLayer)),
+    yield* Effect.never
+  }),
 })

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -95,6 +95,7 @@ const appGlobalBindingCommands = [
 ] as const
 
 const appBindingCommands = [
+  "command.palette.show",
   "model.list",
   "model.cycle_recent",
   "model.cycle_recent_reverse",
@@ -928,17 +929,6 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
           dialog.clear()
         },
       },
-      {
-        name: "app.toggle.clear_prompt_history",
-        title: kv.get("clear_prompt_save_history", false)
-          ? "Don't include cleared prompts in history"
-          : "Include cleared prompts in history",
-        category: "System",
-        run: () => {
-          kv.set("clear_prompt_save_history", !kv.get("clear_prompt_save_history", false))
-          dialog.clear()
-        },
-      },
     ].map((command) => ({
       namespace: "palette",
       ...command,
@@ -949,11 +939,6 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
     commands: appCommands(),
   }))
 
-  useBindings(() => ({
-    enabled: () => dialog.stack.length === 0,
-    bindings: tuiConfig.keybinds.get(COMMAND_PALETTE_COMMAND),
-  }))
-
   useBindings(() => ({
     mode: OPENCODE_BASE_MODE,
     bindings: tuiConfig.keybinds.gather("app", appBindingCommands),

packages/opencode/src/cli/cmd/tui/component/dialog-status.tsx

@@ -3,14 +3,12 @@ import { fileURLToPath } from "bun"
 import { useTheme } from "../context/theme"
 import { useDialog } from "@tui/ui/dialog"
 import { useSync } from "@tui/context/sync"
-import { useSDK } from "@tui/context/sdk"
 import { For, Match, Switch, Show, createMemo } from "solid-js"
 
 export type DialogStatusProps = {}
 
 export function DialogStatus() {
   const sync = useSync()
-  const sdk = useSDK()
   const { theme } = useTheme()
   const dialog = useDialog()
 
@@ -52,10 +50,6 @@ export function DialogStatus() {
           esc
         </text>
       </box>
-      <text fg={theme.text}>
-        Server{" "}
-        <span style={{ fg: theme.textMuted }}>{sdk.url === "http://opencode.internal" ? "Embedded" : sdk.url}</span>
-      </text>
       <Show when={Object.keys(sync.data.mcp).length > 0} fallback={<text fg={theme.text}>No MCP Servers</text>}>
         <box>
           <text fg={theme.text}>{Object.keys(sync.data.mcp).length} MCP Servers</text>

packages/opencode/src/cli/cmd/tui/component/prompt/history.tsx

@@ -87,7 +87,6 @@ export const { use: usePromptHistory, provider: PromptHistoryProvider } = create
         return store.history.at(store.index)
       },
       append(item: PromptInfo) {
-        if (store.history.at(-1)?.input === item.input) return
         const entry = structuredClone(unwrap(item))
         if (isDuplicateEntry(store.history.at(-1), entry)) {
           setStore("index", 0)

packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx

@@ -159,7 +159,6 @@ export function Prompt(props: PromptProps) {
   const dimensions = useTerminalDimensions()
   const { theme, syntax } = useTheme()
   const kv = useKV()
-  const [autoaccept, setAutoaccept] = kv.signal<"none" | "edit">("permission_auto_accept", "edit")
   const animationsEnabled = createMemo(() => kv.get("animations_enabled", true))
   const list = createMemo(() => props.placeholders?.normal ?? [])
   const shell = createMemo(() => props.placeholders?.shell ?? [])
@@ -419,17 +418,6 @@ export function Prompt(props: PromptProps) {
 
   const promptCommands = createMemo(() =>
     [
-      {
-        title: autoaccept() === "none" ? "Enable autoedit" : "Disable autoedit",
-        name: "permission.auto_accept.toggle",
-        search: "toggle permissions",
-        keybind: "permission_auto_accept_toggle",
-        category: "Agent",
-        run: () => {
-          setAutoaccept(() => (autoaccept() === "none" ? "edit" : "none"))
-          dialog.clear()
-        },
-      },
       {
         title: "Clear prompt",
         name: "prompt.clear",
@@ -825,67 +813,6 @@ export function Prompt(props: PromptProps) {
     )
   }
 
-  function expandPasteExtmark(extmark: { id: number; start: number; end: number }) {
-    const partIndex = store.extmarkToPartIndex.get(extmark.id)
-    const part = partIndex === undefined ? undefined : store.prompt.parts[partIndex]
-    if (part?.type !== "text" || !part.source?.text) return false
-
-    const nextInput = store.prompt.input.slice(0, extmark.start) + part.text + store.prompt.input.slice(extmark.end)
-    const delta = part.text.length - (extmark.end - extmark.start)
-    const nextParts = store.prompt.parts
-      .flatMap((item, index) => {
-        if (index === partIndex) return []
-        const next = structuredClone(unwrap(item))
-        if (next.type === "agent" && next.source && next.source.start >= extmark.end) {
-          next.source.start += delta
-          next.source.end += delta
-        }
-        if (next.type === "file" && next.source?.text && next.source.text.start >= extmark.end) {
-          next.source.text.start += delta
-          next.source.text.end += delta
-        }
-        if (next.type === "text" && next.source?.text && next.source.text.start >= extmark.end) {
-          next.source.text.start += delta
-          next.source.text.end += delta
-        }
-        return [next]
-      })
-      .filter((item): item is PromptInfo["parts"][number] => item !== undefined)
-
-    input.setText(nextInput)
-    setStore("prompt", {
-      input: nextInput,
-      parts: nextParts,
-    })
-    restoreExtmarksFromParts(nextParts)
-    input.cursorOffset = extmark.start + part.text.length
-    return true
-  }
-
-  function expandPasteBlockAtMouse(event: MouseEvent) {
-    if (event.button !== 0) return false
-    const localX = event.x - input.x
-    const localY = event.y - input.y
-    if (localX < 0 || localY < 0 || localX >= input.width || localY >= input.height) return false
-
-    const previousOffset = input.cursorOffset
-    input.editorView.setLocalSelection(localX, localY, localX, localY, undefined, undefined, true, false)
-    input.editorView.resetLocalSelection()
-    const offset = input.cursorOffset
-    const extmark = input.extmarks.getAllForTypeId(promptPartTypeId).find((item) => {
-      const partIndex = store.extmarkToPartIndex.get(item.id)
-      const part = partIndex === undefined ? undefined : store.prompt.parts[partIndex]
-      if (part?.type !== "text") return false
-      return (offset >= item.start && offset <= item.end) || (offset + 1 >= item.start && offset + 1 <= item.end)
-    })
-    if (!extmark) {
-      input.cursorOffset = previousOffset
-      return false
-    }
-
-    return expandPasteExtmark(extmark)
-  }
-
   const stashCommands = createMemo(() =>
     [
       {
@@ -1260,27 +1187,25 @@ export function Prompt(props: PromptProps) {
           })),
       })
     } else {
-      const parts = [
-        ...editorParts,
-        {
-          id: PartID.ascending(),
-          type: "text" as const,
-          text: inputText,
-        },
-        ...nonTextParts.map(assign),
-      ]
-      const request = {
-        sessionID,
-        messageID,
-        agent: agent.name,
-        model: selectedModel,
-        variant,
-        parts,
-      }
-      sync.session.addOptimisticPrompt(request)
       sdk.client.session
-        .prompt(request)
-        .catch(() => sync.session.removeOptimisticPrompt(request.sessionID, request.messageID))
+        .prompt({
+          sessionID,
+          ...selectedModel,
+          messageID,
+          agent: agent.name,
+          model: selectedModel,
+          variant,
+          parts: [
+            ...editorParts,
+            {
+              id: PartID.ascending(),
+              type: "text",
+              text: inputText,
+            },
+            ...nonTextParts.map(assign),
+          ],
+        })
+        .catch(() => {})
       if (editorParts.length > 0) editor.markSelectionSent()
     }
     history.append({
@@ -1453,8 +1378,7 @@ export function Prompt(props: PromptProps) {
   }
 
   function clearPrompt() {
-    const shouldSave = store.prompt.input.trim().length >= DRAFT_RETENTION_MIN_CHARS || store.prompt.parts.length > 0
-    if (shouldSave || kv.get("clear_prompt_save_history", false)) {
+    if (store.prompt.input.trim().length >= DRAFT_RETENTION_MIN_CHARS || store.prompt.parts.length > 0) {
       history.append({
         ...store.prompt,
         mode: store.mode,
@@ -1641,11 +1565,6 @@ export function Prompt(props: PromptProps) {
                 }, 0)
               }}
               onMouseDown={(r: MouseEvent) => r.target?.focus()}
-              onMouseUp={(event: MouseEvent) => {
-                if (!expandPasteBlockAtMouse(event)) return
-                event.preventDefault()
-                event.stopPropagation()
-              }}
               focusedBackgroundColor={theme.backgroundElement}
               cursorColor={props.disabled ? theme.backgroundElement : theme.text}
               syntaxStyle={syntax()}
@@ -1682,14 +1601,9 @@ export function Prompt(props: PromptProps) {
                   )}
                 </Show>
               </box>
-              <Show when={hasRightContent() || autoaccept() === "edit"}>
+              <Show when={hasRightContent()}>
                 <box flexDirection="row" gap={1} alignItems="center">
-                  <Show when={hasRightContent()}>{props.right}</Show>
-                  <Show when={autoaccept() === "edit"}>
-                    <text>
-                      <span style={{ fg: theme.warning }}>autoedit</span>
-                    </text>
-                  </Show>
+                  {props.right}
                 </box>
               </Show>
             </box>

packages/opencode/src/cli/cmd/tui/config/tui.ts

@@ -12,7 +12,6 @@ import { Flag } from "@opencode-ai/core/flag/flag"
 import { isRecord } from "@/util/record"
 import { Global } from "@opencode-ai/core/global"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Substitution } from "@opencode-ai/core/substitution"
 import { CurrentWorkingDirectory } from "./cwd"
 import { ConfigPlugin } from "@/config/plugin"
 import { TuiKeybind } from "./keybind"
@@ -20,6 +19,7 @@ import { InstallationLocal, InstallationVersion } from "@opencode-ai/core/instal
 import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import { Filesystem } from "@/util/filesystem"
 import * as Log from "@opencode-ai/core/util/log"
+import { ConfigVariable } from "@/config/variable"
 import { Npm } from "@opencode-ai/core/npm"
 import type { DeepMutable } from "@opencode-ai/core/schema"
 import type { TuiAttentionSoundName } from "@opencode-ai/plugin/tui"
@@ -98,7 +98,6 @@ function dropUnknownKeybinds(input: Record<string, unknown>, configFilepath: str
 
 const loadState = Effect.fn("TuiConfig.loadState")(function* (ctx: { directory: string }) {
   const afs = yield* AppFileSystem.Service
-  const substitution = yield* Substitution.Service
   let appliedOrder = 0
 
   const resolvePlugins = (config: Info, configFilepath: string): Effect.Effect<Info> =>
@@ -113,7 +112,9 @@ const loadState = Effect.fn("TuiConfig.loadState")(function* (ctx: { directory:
 
   const load = (text: string, configFilepath: string): Effect.Effect<Info> =>
     Effect.gen(function* () {
-      const expanded = yield* substitution.substitute({ text, type: "path", path: configFilepath, missing: "empty" }).pipe(Effect.orDie)
+      const expanded = yield* Effect.promise(() =>
+        ConfigVariable.substitute({ text, type: "path", path: configFilepath, missing: "empty" }),
+      )
       const data = ConfigParse.jsonc(expanded, configFilepath)
       if (!isRecord(data)) return {} as Info
       // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
@@ -294,11 +295,7 @@ export const layer = Layer.effect(
   }).pipe(Effect.withSpan("TuiConfig.layer")),
 )
 
-export const defaultLayer = layer.pipe(
-  Layer.provide(Npm.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Substitution.defaultLayer),
-)
+export const defaultLayer = layer.pipe(Layer.provide(Npm.defaultLayer), Layer.provide(AppFileSystem.defaultLayer))
 
 const { runPromise } = makeRuntime(Service, defaultLayer)
 

packages/opencode/src/cli/cmd/tui/context/sync-optimistic.ts

@@ -1,50 +0,0 @@
-import type { AgentPartInput, FilePartInput, Message, Part, SubtaskPartInput, TextPartInput } from "@opencode-ai/sdk/v2"
-import { Binary } from "@opencode-ai/core/util/binary"
-
-export type OptimisticPromptPart = (TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput) & { id: string }
-
-export function optimisticParts(input: { sessionID: string; messageID: string; parts: OptimisticPromptPart[] }) {
-  return input.parts.map((part): Part => {
-    const withIDs = {
-      ...part,
-      sessionID: input.sessionID,
-      messageID: input.messageID,
-    }
-    if (withIDs.type === "file") return { ...withIDs, url: "" }
-    return withIDs
-  })
-}
-
-export function mergeFetchedMessages(input: {
-  currentMessages: Message[]
-  currentParts: Record<string, Part[] | undefined>
-  fetched: { info: Message; parts: Part[] }[]
-  optimisticMessages: ReadonlySet<string>
-}) {
-  const fetchedIDs = new Set(input.fetched.map((message) => message.info.id))
-  const messages = input.fetched.map((message) => message.info)
-  const parts = new Map<string, Part[]>()
-  const resolved = new Set<string>()
-
-  for (const message of input.currentMessages) {
-    if (input.optimisticMessages.has(message.id) && !fetchedIDs.has(message.id)) {
-      Binary.insert(messages, message, (item) => item.id)
-    }
-  }
-
-  for (const message of input.fetched) {
-    if (message.parts.length > 0) {
-      resolved.add(message.info.id)
-      parts.set(message.info.id, message.parts)
-      continue
-    }
-    if (input.optimisticMessages.has(message.info.id)) {
-      const current = input.currentParts[message.info.id]
-      if (current) parts.set(message.info.id, current)
-      continue
-    }
-    parts.set(message.info.id, message.parts)
-  }
-
-  return { messages, parts, resolved }
-}

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -27,13 +27,12 @@ import { createSimpleContext } from "./helper"
 import type { Snapshot } from "@/snapshot"
 import { useExit } from "./exit"
 import { useArgs } from "./args"
-import { useKV } from "./kv"
 import { batch, onMount } from "solid-js"
 import * as Log from "@opencode-ai/core/util/log"
 import { emptyConsoleState, type ConsoleState } from "@/config/console-state"
 import path from "path"
+import { useKV } from "./kv"
 import { aggregateFailures } from "./aggregate-failures"
-import { mergeFetchedMessages, optimisticParts, type OptimisticPromptPart } from "./sync-optimistic"
 
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
@@ -112,12 +111,10 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     const project = useProject()
     const sdk = useSDK()
     const kv = useKV()
-    const [autoaccept] = kv.signal<"none" | "edit">("permission_auto_accept", "edit")
 
     const fullSyncedSessions = new Set<string>()
     const syncingSessions = new Map<string, Promise<void>>()
     const hydratingSessions = new Map<string, { messages: Set<string>; parts: Set<string> }>()
-    const optimisticMessages = new Set<string>()
     const touchMessage = (sessionID: string, messageID: string) => {
       hydratingSessions.get(sessionID)?.messages.add(messageID)
     }
@@ -163,13 +160,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
 
         case "permission.asked": {
           const request = event.properties
-          if (autoaccept() === "edit" && request.permission === "edit") {
-            sdk.client.permission.reply({
-              reply: "once",
-              requestID: request.id,
-            })
-            break
-          }
           const requests = store.permission[request.sessionID]
           if (!requests) {
             setStore("permission", request.sessionID, [request])
@@ -237,7 +227,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
 
         case "session.deleted": {
-          for (const message of store.message[event.properties.info.id] ?? []) optimisticMessages.delete(message.id)
           const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
           if (result.found) {
             setStore(
@@ -311,7 +300,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         }
         case "message.removed": {
           touchMessage(event.properties.sessionID, event.properties.messageID)
-          optimisticMessages.delete(event.properties.messageID)
           const messages = store.message[event.properties.sessionID]
           const result = Binary.search(messages, event.properties.messageID, (m) => m.id)
           if (result.found) {
@@ -327,7 +315,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         }
         case "message.part.updated": {
           touchPart(event.properties.part.sessionID, event.properties.part.id)
-          optimisticMessages.delete(event.properties.part.messageID)
           const parts = store.part[event.properties.part.messageID]
           if (!parts) {
             setStore("part", event.properties.part.messageID, [event.properties.part])
@@ -544,66 +531,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           if (last.role === "user") return "working"
           return last.time.completed ? "idle" : "working"
         },
-        addOptimisticPrompt(input: {
-          sessionID: string
-          messageID: string
-          agent: string
-          model: { providerID: string; modelID: string }
-          variant?: string
-          parts: OptimisticPromptPart[]
-        }) {
-          optimisticMessages.add(input.messageID)
-          const messages = store.message[input.sessionID]
-          const match = messages ? Binary.search(messages, input.messageID, (m) => m.id) : undefined
-          const info: Message = {
-            id: input.messageID,
-            sessionID: input.sessionID,
-            role: "user",
-            time: { created: Date.now() },
-            agent: input.agent,
-            model: {
-              providerID: input.model.providerID,
-              modelID: input.model.modelID,
-              ...(input.variant ? { variant: input.variant } : {}),
-            },
-          }
-          batch(() => {
-            if (!messages) {
-              setStore("message", input.sessionID, [info])
-            } else if (!match?.found) {
-              setStore(
-                "message",
-                input.sessionID,
-                produce((draft) => {
-                  Binary.insert(draft, info, (message) => message.id)
-                }),
-              )
-            }
-            setStore("part", input.messageID, reconcile(optimisticParts(input)))
-          })
-        },
-        removeOptimisticPrompt(sessionID: string, messageID: string) {
-          if (!optimisticMessages.delete(messageID)) return
-          const messages = store.message[sessionID]
-          const match = messages ? Binary.search(messages, messageID, (m) => m.id) : undefined
-          batch(() => {
-            if (match?.found) {
-              setStore(
-                "message",
-                sessionID,
-                produce((draft) => {
-                  draft.splice(match.index, 1)
-                }),
-              )
-            }
-            setStore(
-              "part",
-              produce((draft) => {
-                delete draft[messageID]
-              }),
-            )
-          })
-        },
         async sync(sessionID: string) {
           if (fullSyncedSessions.has(sessionID)) return
           const syncing = syncingSessions.get(sessionID)
@@ -620,16 +547,13 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
             setStore(
               produce((draft) => {
                 const match = Binary.search(draft.session, sessionID, (s) => s.id)
-                const merged = mergeFetchedMessages({
-                  currentMessages: draft.message[sessionID] ?? [],
-                  currentParts: draft.part,
-                  fetched: messages.data ?? [],
-                  optimisticMessages,
-                })
+                if (match.found) draft.session[match.index] = session.data!
+                if (!match.found) draft.session.splice(match.index, 0, session.data!)
+                draft.todo[sessionID] = todo.data ?? []
                 const currentMessages = draft.message[sessionID] ?? []
-                const infos = merged.messages.flatMap((message) => {
-                  if (!tracker.messages.has(message.id)) return [message]
-                  const current = currentMessages.find((item) => item.id === message.id)
+                const infos = (messages.data ?? []).flatMap((message) => {
+                  if (!tracker.messages.has(message.info.id)) return [message.info]
+                  const current = currentMessages.find((item) => item.id === message.info.id)
                   return current ? [current] : []
                 })
                 infos.push(
@@ -639,17 +563,14 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
                 )
                 const removed = infos.slice(0, -100)
                 const visible = infos.slice(-100)
-                if (match.found) draft.session[match.index] = session.data!
-                if (!match.found) draft.session.splice(match.index, 0, session.data!)
-                draft.todo[sessionID] = todo.data ?? []
-                for (const messageID of merged.resolved) {
-                  optimisticMessages.delete(messageID)
-                }
-                for (const message of visible) {
-                  const currentParts = draft.part[message.id] ?? []
-                  const fetchedParts = merged.parts.get(message.id)
-                  if (!fetchedParts) continue
-                  const parts = fetchedParts.flatMap((part) => {
+                const visibleIDs = new Set(visible.map((message) => message.id))
+                for (const message of messages.data ?? []) {
+                  if (!visibleIDs.has(message.info.id)) {
+                    delete draft.part[message.info.id]
+                    continue
+                  }
+                  const currentParts = draft.part[message.info.id] ?? []
+                  const parts = message.parts.flatMap((part) => {
                     const current = currentParts.find((item) => item.id === part.id)
                     if (tracker.parts.has(part.id)) return current ? [current] : []
                     if (
@@ -668,7 +589,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
                       (part) => tracker.parts.has(part.id) && !parts.some((item) => item.id === part.id),
                     ),
                   )
-                  draft.part[message.id] = parts
+                  draft.part[message.info.id] = parts
                 }
                 for (const message of removed) delete draft.part[message.id]
                 draft.message[sessionID] = visible

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -91,7 +91,6 @@ import { SessionRetry } from "@/session/retry"
 import { getRevertDiffFiles } from "../../util/revert-diff"
 import { OPENCODE_BASE_MODE, useBindings, useCommandShortcut, useOpencodeKeymap } from "../../keymap"
 import { PathFormatterProvider, usePathFormatter } from "../../context/path-format"
-import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
 
 addDefaultParsers(parsers.parsers)
 
@@ -101,7 +100,6 @@ const GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT = "go_upsell_account_rate_limit_
 const GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW = "go_upsell_account_rate_limit_dont_show"
 const GO_UPSELL_WINDOW = 86_400_000 // 24 hrs
 const GO_UPSELL_PROVIDERS = new Set(["opencode", "opencode-go"])
-const SESSION_RENDER_STATE_CHANNELS = new Set(["local", "dev", "beta"])
 
 function goUpsellKeys(action: SessionRetry.Retryable["action"]) {
   if (!action) return
@@ -417,49 +415,6 @@ export function Session() {
     }, 50)
   }
 
-  async function dumpRenderState() {
-    const timestamp = Date.now()
-    const maxTop = Math.max(0, scroll.scrollHeight - scroll.viewport.height)
-    const filename = `session-${route.sessionID.slice(0, 8)}-render-state-${timestamp}.json`
-    renderer.dumpBuffers(timestamp)
-    await Filesystem.writeJson(path.join(process.cwd(), filename), {
-      capturedAt: timestamp,
-      channel: InstallationChannel,
-      version: InstallationVersion,
-      sessionID: route.sessionID,
-      scroll: {
-        top: scroll.scrollTop,
-        height: scroll.scrollHeight,
-        viewportHeight: scroll.viewport.height,
-        maxTop,
-        atBottom: scroll.scrollTop >= maxTop,
-      },
-      messages: messages().map((message) => ({
-        id: message.id,
-        role: message.role,
-        parts: (sync.data.part[message.id] ?? []).map((part) => {
-          const renderable = scroll.findDescendantById(`text-${part.id}`)
-          return {
-            id: part.id,
-            type: part.type,
-            ...((part.type === "text" || part.type === "reasoning") && { textLength: part.text.length }),
-            ...(renderable && {
-              renderable: {
-                id: renderable.id,
-                x: renderable.x,
-                y: renderable.y,
-                width: renderable.width,
-                height: renderable.height,
-                visible: renderable.visible,
-              },
-            }),
-          }
-        }),
-      })),
-    })
-    toast.show({ message: `Session render state written to ${filename}`, variant: "success" })
-  }
-
   const local = useLocal()
 
   function enterChild(sessionID: string) {
@@ -1053,23 +1008,6 @@ export function Session() {
         dialog.clear()
       },
     },
-    ...(SESSION_RENDER_STATE_CHANNELS.has(InstallationChannel)
-      ? [
-          {
-            title: "Dump session render state",
-            value: "session.debug.dump_render_state",
-            category: "Debug",
-            run: async () => {
-              try {
-                await dumpRenderState()
-              } catch {
-                toast.show({ message: "Failed to dump session render state", variant: "error" })
-              }
-              dialog.clear()
-            },
-          },
-        ]
-      : []),
     {
       title: "Go to child session",
       value: "session.child.first",

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -9,8 +9,6 @@ import { errorMessage } from "@/util/error"
 import { withTimeout } from "@/util/timeout"
 import { withNetworkOptions, resolveNetworkOptionsNoConfig } from "@/cli/network"
 import { Filesystem } from "@/util/filesystem"
-import { ServerAuth } from "@/server/auth"
-import { ServerDiscovery } from "@/cli/server-discovery"
 import type { GlobalEvent } from "@opencode-ai/sdk/v2"
 import type { EventSource } from "./context/sdk"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
@@ -199,26 +197,16 @@ export const TuiThreadCommand = cmd({
         network.mdns ||
         network.port !== 0 ||
         network.hostname !== "127.0.0.1"
-      const discovered = external ? undefined : await ServerDiscovery.find()
 
       const transport = external
         ? {
             url: (await client.call("server", network)).url,
             fetch: undefined,
-            headers: ServerAuth.headers(),
             events: undefined,
           }
-        : discovered
-          ? {
-              url: discovered,
-              fetch: undefined,
-              headers: ServerAuth.headers(),
-              events: undefined,
-            }
         : {
             url: "http://opencode.internal",
             fetch: createWorkerFetch(client),
-            headers: undefined,
             events: createEventSource(client),
           }
 
@@ -228,7 +216,6 @@ export const TuiThreadCommand = cmd({
           sessionID: args.session,
           directory: cwd,
           fetch: transport.fetch,
-          headers: transport.headers,
         })
       } catch (error) {
         UI.error(errorMessage(error))
@@ -254,7 +241,6 @@ export const TuiThreadCommand = cmd({
           config,
           directory: cwd,
           fetch: transport.fetch,
-          headers: transport.headers,
           events: transport.events,
           args: {
             continue: args.continue,

packages/opencode/src/cli/cmd/tui/ui/dialog-select.tsx

@@ -52,7 +52,6 @@ export interface DialogSelectOption<T = any> {
   value: T
   description?: string
   details?: string[]
-  search?: string
   footer?: JSX.Element | string
   category?: string
   categoryView?: JSX.Element
@@ -129,8 +128,8 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     // users typically search by the item name, and not its category.
     const result = fuzzysort
       .go(needle, options, {
-        keys: ["title", "category", "search"],
-        scoreFn: (r) => r[0].score * 2 + r[1].score + r[2].score,
+        keys: ["title", "category"],
+        scoreFn: (r) => r[0].score * 2 + r[1].score,
       })
       .map((x) => x.obj)
 

packages/opencode/src/cli/server-discovery.ts

@@ -1,112 +0,0 @@
-export * as ServerDiscovery from "./server-discovery"
-
-import { makeRuntime } from "@/effect/run-service"
-import { ServerAuth } from "@/server/auth"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Global } from "@opencode-ai/core/global"
-import { Context, Effect, Layer, Option, Schema } from "effect"
-import { readFileSync, unlinkSync } from "fs"
-import path from "path"
-
-export const file = path.join(Global.Path.state, "server.json")
-
-const Entry = Schema.Struct({
-  url: Schema.String,
-  pid: Schema.Number,
-})
-type Entry = typeof Entry.Type
-const decodeEntry = Schema.decodeUnknownOption(Entry)
-
-export interface Interface {
-  readonly write: (url: URL) => Effect.Effect<void>
-  readonly remove: () => Effect.Effect<void>
-  readonly find: () => Effect.Effect<string | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/CliServerDiscovery") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    const read = Effect.fn("CliServerDiscovery.read")(function* () {
-      const entry = yield* fs.readJson(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      return Option.getOrUndefined(decodeEntry(entry))
-    })
-
-    const remove = Effect.fn("CliServerDiscovery.remove")(function* () {
-      const entry = yield* read()
-      if (entry?.pid !== process.pid) return
-      yield* fs.remove(file).pipe(Effect.ignore)
-    })
-
-    const removeStale = Effect.fn("CliServerDiscovery.removeStale")(function* (entry: Entry) {
-      const current = yield* read()
-      if (current?.pid !== entry.pid || current.url !== entry.url) return
-      yield* fs.remove(file).pipe(Effect.ignore)
-    })
-
-    return Service.of({
-      write: Effect.fn("CliServerDiscovery.write")(function* (url) {
-        yield* fs.writeJson(file, { url: localURL(url).toString(), pid: process.pid }, 0o600).pipe(Effect.orDie)
-      }),
-      remove,
-      find: Effect.fn("CliServerDiscovery.find")(function* () {
-        const entry = yield* read()
-        if (!entry) return undefined
-        const url = yield* healthy(entry.url)
-        if (url) return url
-        yield* removeStale(entry)
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
-
-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export const find = () => runPromise((discovery) => discovery.find())
-
-export function removeSync() {
-  const entry = readSync()
-  if (entry?.pid !== process.pid) return
-  try {
-    unlinkSync(file)
-  } catch {}
-}
-
-function readSync() {
-  try {
-    return Option.getOrUndefined(decodeEntry(JSON.parse(readFileSync(file, "utf8"))))
-  } catch {
-    return undefined
-  }
-}
-
-function healthy(input: string) {
-  return Effect.tryPromise({
-    try: async () => {
-      const url = new URL(input)
-      if (url.protocol !== "http:" && url.protocol !== "https:") return undefined
-      const response = await fetch(new URL("/global/health", url), {
-        headers: ServerAuth.headers(),
-        signal: AbortSignal.timeout(1000),
-      })
-      if (!response.ok) return undefined
-      const body = (await response.json()) as unknown
-      if (typeof body === "object" && body !== null && "healthy" in body && body.healthy === true) {
-        return url.toString()
-      }
-    },
-    catch: () => undefined,
-  }).pipe(Effect.catch(() => Effect.succeed(undefined)))
-}
-
-function localURL(url: URL) {
-  const result = new URL(url)
-  if (result.hostname === "0.0.0.0") result.hostname = "127.0.0.1"
-  if (result.hostname === "::") result.hostname = "::1"
-  return result
-}

packages/opencode/src/config/config.ts

@@ -8,8 +8,7 @@ import { Global } from "@opencode-ai/core/global"
 import fsNode from "fs/promises"
 import { NamedError } from "@opencode-ai/core/util/error"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { AuthWellKnown } from "@opencode-ai/core/auth-well-known"
-import { Substitution } from "@opencode-ai/core/substitution"
+import { Auth } from "../auth"
 import { Env } from "../env"
 import { applyEdits, modify } from "jsonc-parser"
 import { InstallationLocal, InstallationVersion } from "@opencode-ai/core/installation/version"
@@ -20,7 +19,7 @@ import type { ConsoleState } from "./console-state"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { InstanceState } from "@/effect/instance-state"
 import { Context, Duration, Effect, Exit, Fiber, Layer, Option, Schema } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
 import { containsPath, type InstanceContext } from "../project/instance-context"
 import { NonNegativeInt, PositiveInt, type DeepMutable } from "@opencode-ai/core/schema"
@@ -41,7 +40,9 @@ import { ConfigProvider } from "./provider"
 import { ConfigReference } from "./reference"
 import { ConfigServer } from "./server"
 import { ConfigSkills } from "./skills"
+import { ConfigVariable } from "./variable"
 import { Npm } from "@opencode-ai/core/npm"
+import { withTransientReadRetry } from "@/util/effect-http-client"
 import { ConfigExperimental } from "@opencode-ai/core/config/experimental"
 
 const log = Log.create({ service: "config" })
@@ -72,6 +73,48 @@ function normalizeLoadedConfig(data: unknown, source: string) {
   return copy
 }
 
+async function substituteWellKnownRemoteConfig(input: {
+  value: unknown
+  dir: string
+  source: string
+  env: Record<string, string>
+}) {
+  if (!isRecord(input.value) || typeof input.value.url !== "string") return undefined
+
+  const url = await ConfigVariable.substitute({
+    text: input.value.url,
+    type: "virtual",
+    dir: input.dir,
+    source: input.source,
+    env: input.env,
+  })
+  const headers = isRecord(input.value.headers)
+    ? Object.fromEntries(
+        await Promise.all(
+          Object.entries(input.value.headers)
+            .filter((entry): entry is [string, string] => typeof entry[1] === "string")
+            .map(async ([key, value]) => [
+              key,
+              await ConfigVariable.substitute({
+                text: value,
+                type: "virtual",
+                dir: input.dir,
+                source: input.source,
+                env: input.env,
+              }),
+            ]),
+        ),
+      )
+    : undefined
+
+  return { url, headers }
+}
+
+const WellKnownConfig = Schema.Struct({
+  config: Schema.optional(Schema.Json),
+  remote_config: Schema.optional(Schema.Json),
+})
+
 async function resolveLoadedPlugins<T extends { plugin?: ConfigPlugin.Spec[] }>(config: T, filepath: string) {
   if (!config.plugin) return config
   for (let i = 0; i < config.plugin.length; i++) {
@@ -343,25 +386,44 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const fs = yield* AppFileSystem.Service
-    const authWellKnown = yield* AuthWellKnown.Service
-    const substitution = yield* Substitution.Service
+    const authSvc = yield* Auth.Service
     const accountSvc = yield* Account.Service
     const env = yield* Env.Service
     const npmSvc = yield* Npm.Service
+    const http = yield* HttpClient.HttpClient
 
     const readConfigFile = (filepath: string) => fs.readFileStringSafe(filepath).pipe(Effect.orDie)
 
+    const fetchRemoteJson = Effect.fnUntraced(function* <S extends Schema.Top>(
+      url: string,
+      headers: Record<string, string> | undefined,
+      schema: S,
+    ) {
+      const response = yield* HttpClient.filterStatusOk(withTransientReadRetry(http))
+        .execute(
+          HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers ?? {})),
+        )
+        .pipe(
+          Effect.catch((error) => Effect.die(new Error(`failed to fetch remote config from ${url}: ${String(error)}`))),
+        )
+      return yield* HttpClientResponse.schemaBodyJson(schema)(response).pipe(
+        Effect.catch((error) => Effect.die(new Error(`failed to decode remote config from ${url}: ${String(error)}`))),
+      )
+    })
+
     const loadConfig = Effect.fnUntraced(function* (
       text: string,
       options: { path: string } | { dir: string; source: string },
       env?: Record<string, string>,
     ) {
       const source = "path" in options ? options.path : options.source
-      const expanded = yield* substitution.substitute(
-        "path" in options
-          ? { text, type: "path", path: options.path, env }
-          : { text, type: "virtual", ...options, env },
-      ).pipe(Effect.orDie)
+      const expanded = yield* Effect.promise(() =>
+        ConfigVariable.substitute(
+          "path" in options
+            ? { text, type: "path", path: options.path, env }
+            : { text, type: "virtual", ...options, env },
+        ),
+      )
       const parsed = ConfigParse.jsonc(expanded, source)
       const data = ConfigParse.schema(Info, normalizeLoadedConfig(parsed, source), source)
       if (!("path" in options)) return data
@@ -451,6 +513,8 @@ export const layer = Layer.effect(
 
     const loadInstanceState = Effect.fn("Config.loadInstanceState")(
       function* (ctx: InstanceContext) {
+        const auth = yield* authSvc.all().pipe(Effect.orDie)
+
         let result: Info = {}
         const authEnv: Record<string, string> = {}
         const consoleManagedProviders = new Set<string>()
@@ -489,13 +553,46 @@ export const layer = Layer.effect(
           return mergePluginOrigins(source, next.plugin, kind)
         }
 
-        for (const item of yield* authWellKnown.configs().pipe(Effect.orDie)) {
-          yield* merge(
-            item.source,
-            yield* loadConfig(JSON.stringify(item.content), { dir: item.dir, source: item.source }, authEnv),
-            "global",
-          )
-          log.debug("loaded well-known config", { url: item.url })
+        for (const [key, value] of Object.entries(auth)) {
+          if (value.type === "wellknown") {
+            const url = key.replace(/\/+$/, "")
+            authEnv[value.key] = value.token
+            const wellknownURL = `${url}/.well-known/opencode`
+            log.debug("fetching remote config", { url: wellknownURL })
+            const wellknown = yield* fetchRemoteJson(wellknownURL, undefined, WellKnownConfig)
+            const remote = yield* Effect.promise(() =>
+              substituteWellKnownRemoteConfig({
+                value: wellknown.remote_config,
+                dir: url,
+                source: wellknownURL,
+                env: authEnv,
+              }),
+            )
+            const fetchedConfig = remote
+              ? yield* Effect.gen(function* () {
+                  log.debug("fetching remote config", { url: remote.url })
+                  const data = yield* fetchRemoteJson(remote.url, remote.headers, Schema.Json)
+                  if (isRecord(data) && isRecord(data.config)) return data.config
+                  if (isRecord(data)) return data
+                  return yield* Effect.die(
+                    new Error(`failed to decode remote config from ${remote.url}: expected object`),
+                  )
+                })
+              : {}
+            const remoteConfig = mergeConfig(isRecord(wellknown.config) ? wellknown.config : {}, fetchedConfig)
+            if (!remoteConfig.$schema) remoteConfig.$schema = "https://opencode.ai/config.json"
+            const source = wellknownURL
+            const next = yield* loadConfig(
+              JSON.stringify(remoteConfig),
+              {
+                dir: path.dirname(source),
+                source,
+              },
+              authEnv,
+            )
+            yield* merge(source, next, "global")
+            log.debug("loaded remote config from well-known", { url })
+          }
         }
 
         const global = Object.keys(authEnv).length ? yield* loadGlobal(authEnv) : yield* getGlobal()
@@ -782,8 +879,7 @@ export const defaultLayer = layer.pipe(
   Layer.provide(EffectFlock.defaultLayer),
   Layer.provide(AppFileSystem.defaultLayer),
   Layer.provide(Env.defaultLayer),
-  Layer.provide(AuthWellKnown.defaultLayer),
-  Layer.provide(Substitution.defaultLayer),
+  Layer.provide(Auth.defaultLayer),
   Layer.provide(Account.defaultLayer),
   Layer.provide(Npm.defaultLayer),
   Layer.provide(FetchHttpClient.layer),

packages/opencode/src/config/variable.ts

@@ -0,0 +1,91 @@
+export * as ConfigVariable from "./variable"
+
+import path from "path"
+import os from "os"
+import { Filesystem } from "@/util/filesystem"
+import { InvalidError } from "./error"
+
+type ParseSource =
+  | {
+      type: "path"
+      path: string
+    }
+  | {
+      type: "virtual"
+      source: string
+      dir: string
+    }
+
+type SubstituteInput = ParseSource & {
+  text: string
+  missing?: "error" | "empty"
+  env?: Record<string, string>
+}
+
+function source(input: ParseSource) {
+  return input.type === "path" ? input.path : input.source
+}
+
+function dir(input: ParseSource) {
+  return input.type === "path" ? path.dirname(input.path) : input.dir
+}
+
+/** Apply {env:VAR} and {file:path} substitutions to config text. */
+export async function substitute(input: SubstituteInput) {
+  const missing = input.missing ?? "error"
+  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
+    return (input.env?.[varName] ?? process.env[varName]) || ""
+  })
+
+  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
+  if (!fileMatches.length) return text
+
+  const configDir = dir(input)
+  const configSource = source(input)
+  let out = ""
+  let cursor = 0
+
+  for (const match of fileMatches) {
+    const token = match[0]
+    const index = match.index
+    out += text.slice(cursor, index)
+
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1
+    const prefix = text.slice(lineStart, index).trimStart()
+    if (prefix.startsWith("//")) {
+      out += token
+      cursor = index + token.length
+      continue
+    }
+
+    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
+    if (filePath.startsWith("~/")) {
+      filePath = path.join(os.homedir(), filePath.slice(2))
+    }
+
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
+    const fileContent = (
+      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
+        if (missing === "empty") return ""
+
+        const errMsg = `bad file reference: "${token}"`
+        if (error.code === "ENOENT") {
+          throw new InvalidError(
+            {
+              path: configSource,
+              message: errMsg + ` ${resolvedPath} does not exist`,
+            },
+            { cause: error },
+          )
+        }
+        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
+      })
+    ).trim()
+
+    out += JSON.stringify(fileContent).slice(1, -1)
+    cursor = index + token.length
+  }
+
+  out += text.slice(cursor)
+  return out
+}

packages/opencode/src/effect/app-runtime.ts

@@ -4,7 +4,6 @@ import * as Observability from "@opencode-ai/core/effect/observability"
 
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Database } from "@opencode-ai/core/database/database"
-import { AuthWellKnown } from "@opencode-ai/core/auth-well-known"
 import { Auth } from "@/auth"
 import { Account } from "@/account/account"
 import { Config } from "@/config/config"
@@ -62,7 +61,6 @@ export const AppLayer = Layer.mergeAll(
   Npm.defaultLayer,
   AppFileSystem.defaultLayer,
   Database.defaultLayer,
-  AuthWellKnown.defaultLayer,
   Auth.defaultLayer,
   Account.defaultLayer,
   Config.defaultLayer,

packages/opencode/src/plugin/openai/codex.ts

@@ -14,12 +14,7 @@ const ISSUER = "https://auth.openai.com"
 const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses"
 const OAUTH_PORT = 1455
 const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000
-const ALLOWED_MODELS = new Set([
-  "gpt-5.5",
-  "gpt-5.3-codex-spark",
-  "gpt-5.4",
-  "gpt-5.4-mini",
-])
+const ALLOWED_MODELS = new Set(["gpt-5.5", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini"])
 
 interface PkceCodes {
   verifier: string

packages/opencode/test/agent/plugin-agent-regression.test.ts

@@ -1,6 +1,5 @@
 import { expect } from "bun:test"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Substitution } from "@opencode-ai/core/substitution"
 import { Effect, Layer } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
 import path from "path"
@@ -13,7 +12,6 @@ import { RuntimeFlags } from "../../src/effect/runtime-flags"
 import { Plugin } from "../../src/plugin"
 import { AccountTest } from "../fake/account"
 import { AuthTest } from "../fake/auth"
-import { AuthWellKnownTest } from "../fake/auth-well-known"
 import { NpmTest } from "../fake/npm"
 import { ProviderTest } from "../fake/provider"
 import { SkillTest } from "../fake/skill"
@@ -28,8 +26,6 @@ const pluginUrl = pathToFileURL(path.join(import.meta.dir, "..", "fixture", "age
 const provider = ProviderTest.fake()
 const configLayer = Config.layer.pipe(
   Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(AuthWellKnownTest.empty),
-  Layer.provide(Substitution.defaultLayer),
   Layer.provide(Env.defaultLayer),
   Layer.provide(AuthTest.empty),
   Layer.provide(AccountTest.empty),

packages/opencode/test/cli/help/__snapshots__/help-snapshots.test.ts.snap

@@ -219,20 +219,18 @@ exports[`opencode CLI help-text snapshots every documented command emits stable
 starts a headless opencode server
 
 Options:
-  -h, --help          show help                                                            [boolean]
-  -v, --version       show version number                                                  [boolean]
-      --print-logs    print logs to stderr                                                 [boolean]
-      --log-level     log level                 [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
-      --pure          run without external plugins                                         [boolean]
-      --port          port to listen on                                        [number] [default: 0]
-      --hostname      hostname to listen on                          [string] [default: "127.0.0.1"]
-      --mdns          enable mDNS service discovery (defaults hostname to 0.0.0.0)
+  -h, --help         show help                                                             [boolean]
+  -v, --version      show version number                                                   [boolean]
+      --print-logs   print logs to stderr                                                  [boolean]
+      --log-level    log level                  [string] [choices: "DEBUG", "INFO", "WARN", "ERROR"]
+      --pure         run without external plugins                                          [boolean]
+      --port         port to listen on                                         [number] [default: 0]
+      --hostname     hostname to listen on                           [string] [default: "127.0.0.1"]
+      --mdns         enable mDNS service discovery (defaults hostname to 0.0.0.0)
                                                                           [boolean] [default: false]
-      --mdns-domain   custom domain name for mDNS service (default: opencode.local)
+      --mdns-domain  custom domain name for mDNS service (default: opencode.local)
                                                                 [string] [default: "opencode.local"]
-      --cors          additional domains to allow for CORS                     [array] [default: []]
-      --discoverable  write this server to the local discovery file for default TUI startup
-                                                                          [boolean] [default: false]"
+      --cors         additional domains to allow for CORS                      [array] [default: []]"
 `;
 
 exports[`opencode CLI help-text snapshots every documented command emits stable help text: opencode web --help 1`] = `

packages/opencode/test/cli/tui-sync-optimistic.test.ts

@@ -1,92 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { Message, Part } from "@opencode-ai/sdk/v2"
-import { mergeFetchedMessages, optimisticParts } from "@/cli/cmd/tui/context/sync-optimistic"
-
-function user(id: string): Message {
-  return {
-    id,
-    sessionID: "ses_test",
-    role: "user",
-    time: { created: 1 },
-    agent: "build",
-    model: { providerID: "test", modelID: "model" },
-  }
-}
-
-function text(messageID: string, text: string): Part {
-  return {
-    id: `part_${messageID}`,
-    sessionID: "ses_test",
-    messageID,
-    type: "text",
-    text,
-  }
-}
-
-describe("TUI optimistic prompt sync", () => {
-  test("keeps an optimistic message while session sync has not fetched it yet", () => {
-    const merged = mergeFetchedMessages({
-      currentMessages: [user("msg_2")],
-      currentParts: { msg_2: [text("msg_2", "optimistic")] },
-      fetched: [{ info: user("msg_1"), parts: [text("msg_1", "persisted")] }],
-      optimisticMessages: new Set(["msg_2"]),
-    })
-
-    expect(merged.messages.map((message) => message.id)).toEqual(["msg_1", "msg_2"])
-    expect(merged.parts.get("msg_1")?.map((part) => (part.type === "text" ? part.text : ""))).toEqual(["persisted"])
-    expect(merged.resolved.has("msg_2")).toBe(false)
-  })
-
-  test("preserves optimistic parts when sync fetches the message before its parts", () => {
-    const merged = mergeFetchedMessages({
-      currentMessages: [user("msg_1")],
-      currentParts: { msg_1: [text("msg_1", "optimistic")] },
-      fetched: [{ info: user("msg_1"), parts: [] }],
-      optimisticMessages: new Set(["msg_1"]),
-    })
-
-    expect(merged.messages.map((message) => message.id)).toEqual(["msg_1"])
-    expect(merged.parts.get("msg_1")?.map((part) => (part.type === "text" ? part.text : ""))).toEqual(["optimistic"])
-    expect(merged.resolved.has("msg_1")).toBe(false)
-  })
-
-  test("replaces optimistic parts once real fetched parts arrive", () => {
-    const merged = mergeFetchedMessages({
-      currentMessages: [user("msg_1")],
-      currentParts: { msg_1: [text("msg_1", "optimistic")] },
-      fetched: [{ info: user("msg_1"), parts: [text("msg_1", "persisted")] }],
-      optimisticMessages: new Set(["msg_1"]),
-    })
-
-    expect(merged.parts.get("msg_1")?.map((part) => (part.type === "text" ? part.text : ""))).toEqual(["persisted"])
-    expect(merged.resolved.has("msg_1")).toBe(true)
-  })
-
-  test("strips file URLs from optimistic render parts", () => {
-    const parts = optimisticParts({
-      sessionID: "ses_test",
-      messageID: "msg_1",
-      parts: [
-        {
-          id: "part_file",
-          type: "file",
-          mime: "image/png",
-          filename: "image.png",
-          url: "data:image/png;base64,large",
-        },
-      ],
-    })
-
-    expect(parts).toEqual([
-      {
-        id: "part_file",
-        sessionID: "ses_test",
-        messageID: "msg_1",
-        type: "file",
-        mime: "image/png",
-        filename: "image.png",
-        url: "",
-      },
-    ])
-  })
-})

packages/opencode/test/cli/tui/keymap.test.tsx

@@ -5,7 +5,6 @@ import { expect, test } from "bun:test"
 import { onCleanup } from "solid-js"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import {
-  COMMAND_PALETTE_COMMAND,
   getOpencodeModeStack,
   OPENCODE_BASE_MODE,
   OpencodeKeymapProvider,
@@ -69,14 +68,12 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
     const offKeymap = registerOpencodeKeymap(keymap, renderer, config)
     const offGlobal = keymap.registerLayer({
       commands: [
-        { name: COMMAND_PALETTE_COMMAND, run() {} },
         { name: "session.list", run() {} },
         { name: "session.new", run() {} },
         { name: "session.page.up", run() {} },
         { name: "session.first", run() {} },
       ],
       bindings: config.keybinds.gather("test.global", [
-        COMMAND_PALETTE_COMMAND,
         "session.list",
         "session.new",
         "session.page.up",
@@ -93,7 +90,7 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
         Array.from(
           keymap.getCommandBindings({
             visibility: "active",
-            commands: [COMMAND_PALETTE_COMMAND, "session.list", "session.new", "session.page.up", "session.first", "model.list"],
+            commands: ["session.list", "session.new", "session.page.up", "session.first", "model.list"],
           }),
           ([command, bindings]) => [command, bindings.length],
         ),
@@ -123,24 +120,9 @@ test("mode-less bindings stay active when opencode mode changes", async () => {
   const app = await testRender(() => <Harness />)
   try {
     expect(counts).toEqual({
-      base: {
-        [COMMAND_PALETTE_COMMAND]: 1,
-        "session.list": 1,
-        "session.new": 1,
-        "session.page.up": 2,
-        "session.first": 2,
-        "model.list": 1,
-      },
-      question: {
-        [COMMAND_PALETTE_COMMAND]: 1,
-        "session.list": 1,
-        "session.new": 1,
-        "session.page.up": 2,
-        "session.first": 2,
-        "model.list": 0,
-      },
+      base: { "session.list": 1, "session.new": 1, "session.page.up": 2, "session.first": 2, "model.list": 1 },
+      question: { "session.list": 1, "session.new": 1, "session.page.up": 2, "session.first": 2, "model.list": 0 },
       autocomplete: {
-        [COMMAND_PALETTE_COMMAND]: 1,
         "session.list": 1,
         "session.new": 1,
         "session.page.up": 2,

packages/opencode/test/config/config.test.ts

@@ -1,7 +1,6 @@
 import { test, expect, describe, afterEach, beforeEach, spyOn } from "bun:test"
 import { Effect, Exit, Layer, Option } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { Substitution } from "@opencode-ai/core/substitution"
 import { NodeFileSystem, NodePath } from "@effect/platform-node"
 import { Config } from "@/config/config"
 import { ConfigManaged } from "@/config/managed"
@@ -37,13 +36,13 @@ import { Filesystem } from "@/util/filesystem"
 import { ConfigPlugin } from "@/config/plugin"
 import { AccountTest } from "../fake/account"
 import { AuthTest } from "../fake/auth"
-import { AuthWellKnownTest } from "../fake/auth-well-known"
 import { NpmTest } from "../fake/npm"
 
 /** Infra layer that provides FileSystem, Path, ChildProcessSpawner for test fixtures */
 const infra = CrossSpawnSpawner.defaultLayer.pipe(
   Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)),
 )
+
 const testFlock = EffectFlock.defaultLayer
 
 const unexpectedHttp = HttpClient.make((request) =>
@@ -95,8 +94,6 @@ const configLayer = (
 ) =>
   Config.layer.pipe(
     Layer.provide(testFlock),
-    Layer.provide(Substitution.defaultLayer),
-    Layer.provide(AuthWellKnownTest.empty),
     Layer.provide(Env.defaultLayer),
     Layer.provide(options.auth ?? AuthTest.empty),
     Layer.provide(options.account ?? AccountTest.empty),
@@ -1507,9 +1504,7 @@ test("remote well-known config can use FetchHttpClient layer", async () => {
           Config.layer.pipe(
             Layer.provide(testFlock),
             Layer.provide(AppFileSystem.defaultLayer),
-            Layer.provide(Substitution.defaultLayer),
             Layer.provide(Env.defaultLayer),
-            Layer.provide(AuthWellKnownTest.empty),
             Layer.provide(wellKnownAuth(server.url.origin)),
             Layer.provide(AccountTest.empty),
             Layer.provideMerge(infra),

packages/opencode/test/fake/auth-well-known.ts

@@ -1,8 +0,0 @@
-import { AuthWellKnown } from "@opencode-ai/core/auth-well-known"
-import { Effect, Layer } from "effect"
-
-export const AuthWellKnownTest = {
-  empty: Layer.mock(AuthWellKnown.Service, {
-    configs: () => Effect.succeed([]),
-  }),
-}

packages/opencode/test/plugin/trigger.test.ts

@@ -4,7 +4,6 @@ import { FetchHttpClient } from "effect/unstable/http"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
-import { Substitution } from "@opencode-ai/core/substitution"
 import path from "path"
 import { pathToFileURL } from "url"
 import { EventV2Bridge } from "../../src/event-v2-bridge"
@@ -12,19 +11,17 @@ import { Config } from "../../src/config/config"
 import { Env } from "../../src/env"
 import { RuntimeFlags } from "../../src/effect/runtime-flags"
 import { Plugin } from "../../src/plugin/index"
+
 import { TestInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 import { AccountTest } from "../fake/account"
 import { AuthTest } from "../fake/auth"
 import { NpmTest } from "../fake/npm"
-import { AuthWellKnownTest } from "../fake/auth-well-known"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 
 const configLayer = Config.layer.pipe(
   Layer.provide(EffectFlock.defaultLayer),
   Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(AuthWellKnownTest.empty),
-  Layer.provide(Substitution.defaultLayer),
   Layer.provide(Env.defaultLayer),
   Layer.provide(AuthTest.empty),
   Layer.provide(AccountTest.empty),

packages/opencode/test/plugin/workspace-adapter.test.ts

@@ -5,7 +5,6 @@ import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
-import { Substitution } from "@opencode-ai/core/substitution"
 import path from "path"
 import { pathToFileURL } from "url"
 import { Auth } from "../../src/auth"
@@ -27,13 +26,10 @@ import { testEffect } from "../lib/effect"
 import { AccountTest } from "../fake/account"
 import { AuthTest } from "../fake/auth"
 import { NpmTest } from "../fake/npm"
-import { AuthWellKnownTest } from "../fake/auth-well-known"
 
 const configLayer = Config.layer.pipe(
   Layer.provide(EffectFlock.defaultLayer),
   Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(AuthWellKnownTest.empty),
-  Layer.provide(Substitution.defaultLayer),
   Layer.provide(Env.defaultLayer),
   Layer.provide(AuthTest.empty),
   Layer.provide(AccountTest.empty),

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -2494,7 +2494,7 @@ export type SessionBusyError = {
 }
 
 export type V2SessionsResponse = {
-  items: Array<SessionInfo>
+  items: Array<SessionV2Info>
   cursor: {
     previous?: string
     next?: string
@@ -3369,12 +3369,15 @@ export type ConfigV2ExperimentalPolicy = {
   resource: string
 }
 
-export type SessionInfo = {
+export type LocationRef = {
+  directory: string
+  workspaceID?: string
+}
+
+export type SessionV2Info = {
   id: string
   parentID?: string
   projectID: string
-  workspaceID?: string
-  path?: string
   agent?: string
   model?: {
     id: string
@@ -3397,6 +3400,8 @@ export type SessionInfo = {
     archived?: number
   }
   title: string
+  location: LocationRef
+  subpath?: string
 }
 
 export type SessionDelivery = "immediate" | "deferred"

packages/sdk/openapi.json

@@ -18304,7 +18304,7 @@
           "items": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/SessionInfo"
+              "$ref": "#/components/schemas/SessionV2Info"
             }
           },
           "cursor": {
@@ -20995,7 +20995,20 @@
         "required": ["action", "effect", "resource"],
         "additionalProperties": false
       },
-      "SessionInfo": {
+      "LocationRef": {
+        "type": "object",
+        "properties": {
+          "directory": {
+            "type": "string"
+          },
+          "workspaceID": {
+            "type": "string"
+          }
+        },
+        "required": ["directory"],
+        "additionalProperties": false
+      },
+      "SessionV2Info": {
         "type": "object",
         "properties": {
           "id": {
@@ -21009,13 +21022,6 @@
           "projectID": {
             "type": "string"
           },
-          "workspaceID": {
-            "type": "string",
-            "pattern": "^wrk"
-          },
-          "path": {
-            "type": "string"
-          },
           "agent": {
             "type": "string"
           },
@@ -21085,9 +21091,15 @@
           },
           "title": {
             "type": "string"
+          },
+          "location": {
+            "$ref": "#/components/schemas/LocationRef"
+          },
+          "subpath": {
+            "type": "string"
           }
         },
-        "required": ["id", "projectID", "cost", "tokens", "time", "title"],
+        "required": ["id", "projectID", "cost", "tokens", "time", "title", "location"],
         "additionalProperties": false
       },
       "SessionDelivery": {