fix(windows): handle mapped network drives in path resolution and session matching

On Windows, mapped network drives (e.g. Z:\ -> \server\share\) cause two issues:
1. realpathSync() converts drive letter paths to UNC paths, breaking session
   lookups that use exact string matching on directory paths
2. realpathSync() can throw non-ENOENT errors (EPERM, network timeouts) on
   inaccessible mapped drives, crashing the file listing

Fix by preserving drive letter paths when realpathSync returns UNC, catching
all realpathSync errors on Windows, querying sessions with both drive letter
and UNC path forms, and normalizing paths for case-insensitive comparison in
the frontend project matcher.

Author: jianlinshi

.github/workflows/build-windows.yml

@@ -0,0 +1,48 @@
+name: Build Windows Binary
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: package.json
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Install cross-platform native modules
+        run: |
+          cd packages/opencode
+          bun install --os="*" --cpu="*" @opentui/core@$(bun -e "console.log(require('./package.json').dependencies['@opentui/core'])")
+          bun install --os="*" --cpu="*" @parcel/watcher@$(bun -e "console.log(require('./package.json').dependencies['@parcel/watcher'])")
+
+      - name: Build all targets
+        run: |
+          cd packages/opencode
+          bun run script/build.ts --skip-install
+        env:
+          OPENCODE_VERSION: "0.0.0-local"
+
+      - name: Upload Windows x64
+        uses: actions/upload-artifact@v4
+        with:
+          name: opencode-windows-x64
+          path: packages/opencode/dist/opencode-windows-x64/
+
+      - name: Upload Windows x64-baseline
+        uses: actions/upload-artifact@v4
+        with:
+          name: opencode-windows-x64-baseline
+          path: packages/opencode/dist/opencode-windows-x64-baseline/
+
+      - name: Upload Windows arm64
+        uses: actions/upload-artifact@v4
+        with:
+          name: opencode-windows-arm64
+          path: packages/opencode/dist/opencode-windows-arm64/

packages/app/src/context/global-sync/bootstrap.ts

@@ -140,8 +140,19 @@ function groupBySession<T extends { id: string; sessionID: string }>(input: T[])
   }, {})
 }
 
+function normalizePathForCompare(p: string): string {
+  let v = p.replace(/\\/g, "/").replace(/\/+$/, "")
+  if ((v.length >= 2 && v[1] === ":") || v.startsWith("//")) v = v.toLowerCase()
+  return v
+}
+
 function projectID(directory: string, projects: Project[]) {
-  return projects.find((project) => project.worktree === directory || project.sandboxes?.includes(directory))?.id
+  const key = normalizePathForCompare(directory)
+  return projects.find(
+    (project) =>
+      normalizePathForCompare(project.worktree) === key ||
+      project.sandboxes?.some((s) => normalizePathForCompare(s) === key),
+  )?.id
 }
 
 function mergeSession(setStore: SetStoreFunction<State>, session: Session) {

packages/core/src/filesystem.ts

@@ -194,11 +194,21 @@ export namespace AppFileSystem {
     return lookup(p) || "application/octet-stream"
   }
 
+  function isDriveLetterPath(p: string): boolean {
+    return p.length >= 2 && /^[A-Za-z]:/.test(p)
+  }
+
+  function isUNCPath(p: string): boolean {
+    return p.startsWith("\\\\") || p.startsWith("//")
+  }
+
   export function normalizePath(p: string): string {
     if (process.platform !== "win32") return p
     const resolved = pathResolve(windowsPath(p))
     try {
-      return realpathSync.native(resolved)
+      const real = realpathSync.native(resolved)
+      if (isDriveLetterPath(resolved) && isUNCPath(real)) return resolved
+      return real
     } catch {
       return resolved
     }
@@ -216,9 +226,11 @@ export namespace AppFileSystem {
   export function resolve(p: string): string {
     const resolved = pathResolve(windowsPath(p))
     try {
-      return normalizePath(realpathSync(resolved))
+      const real = realpathSync(resolved)
+      if (process.platform === "win32" && isDriveLetterPath(resolved) && isUNCPath(real)) return normalizePath(resolved)
+      return normalizePath(real)
     } catch (e: any) {
-      if (e?.code === "ENOENT") return normalizePath(resolved)
+      if (process.platform === "win32" || e?.code === "ENOENT") return normalizePath(resolved)
       throw e
     }
   }

packages/opencode/src/project/project.ts

@@ -1,5 +1,5 @@
 import z from "zod"
-import { and } from "drizzle-orm"
+import { and, or } from "drizzle-orm"
 import { Database } from "@/storage/db"
 import { eq } from "drizzle-orm"
 import { ProjectTable } from "./project.sql"
@@ -21,6 +21,7 @@ import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { zod } from "@/util/effect-zod"
 import { NonNegativeInt, optionalOmitUndefined, withStatics } from "@/util/schema"
 import { serviceUse } from "@/effect/service-use"
+import { realpathSync } from "fs"
 
 const log = Log.create({ service: "project" })
 
@@ -344,11 +345,22 @@ export const layer: Layer.Layer<
       )
 
       if (data.id !== ProjectID.global) {
+        const dirs = [data.worktree]
+        if (process.platform === "win32") {
+          try {
+            const real = realpathSync(data.worktree)
+            if (real !== data.worktree) dirs.push(real)
+          } catch {}
+        }
+        const dirCondition =
+          dirs.length > 1
+            ? or(...dirs.map((d) => eq(SessionTable.directory, d)))!
+            : eq(SessionTable.directory, data.worktree)
         yield* db((d) =>
           d
             .update(SessionTable)
             .set({ project_id: data.id })
-            .where(and(eq(SessionTable.project_id, ProjectID.global), eq(SessionTable.directory, data.worktree)))
+            .where(and(eq(SessionTable.project_id, ProjectID.global), dirCondition))
             .run(),
         )
       }

packages/opencode/src/session/session.ts

@@ -1,4 +1,5 @@
 import { Slug } from "@opencode-ai/core/util/slug"
+import { realpathSync } from "fs"
 import path from "path"
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
@@ -55,6 +56,17 @@ export function isDefaultTitle(title: string) {
   ).test(title)
 }
 
+function directoryMatchCondition(directory: string): SQL {
+  if (process.platform !== "win32") return eq(SessionTable.directory, directory)
+  const alternatives = [directory]
+  try {
+    const real = realpathSync(directory)
+    if (real !== directory && !alternatives.includes(real)) alternatives.push(real)
+  } catch {}
+  if (alternatives.length === 1) return eq(SessionTable.directory, directory)
+  return or(...alternatives.map((d) => eq(SessionTable.directory, d)))!
+}
+
 type SessionRow = typeof SessionTable.$inferSelect
 
 export function fromRow(row: SessionRow): Info {
@@ -829,13 +841,13 @@ function* listByProject(
 
       conditions.push(
         input.directory
-          ? or(...conds, and(isNull(SessionTable.path), eq(SessionTable.directory, input.directory))!)!
+          ? or(...conds, and(isNull(SessionTable.path), directoryMatchCondition(input.directory))!)!
           : or(...conds)!,
       )
     }
   } else if (input.scope !== "project" && !Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) {
     if (input.directory) {
-      conditions.push(eq(SessionTable.directory, input.directory))
+      conditions.push(directoryMatchCondition(input.directory))
     }
   }
   if (input.roots) {
@@ -876,7 +888,7 @@ export function* listGlobal(input?: {
   const conditions: SQL[] = []
 
   if (input?.directory) {
-    conditions.push(eq(SessionTable.directory, input.directory))
+    conditions.push(directoryMatchCondition(input.directory))
   }
   if (input?.roots) {
     conditions.push(isNull(SessionTable.parent_id))

packages/opencode/src/util/filesystem.ts

@@ -110,11 +110,22 @@ export async function mimeType(p: string): Promise<string> {
  * This is needed because Windows paths are case-insensitive but LSP servers
  * may return paths with different casing than what we send them.
  */
+
+function isDriveLetterPath(p: string): boolean {
+  return p.length >= 2 && /^[A-Za-z]:/.test(p)
+}
+
+function isUNCPath(p: string): boolean {
+  return p.startsWith("\\\\") || p.startsWith("//")
+}
+
 export function normalizePath(p: string): string {
   if (process.platform !== "win32") return p
   const resolved = win32.normalize(win32.resolve(windowsPath(p)))
   try {
-    return realpathSync.native(resolved)
+    const real = realpathSync.native(resolved)
+    if (isDriveLetterPath(resolved) && isUNCPath(real)) return resolved
+    return real
   } catch {
     return resolved
   }
@@ -135,9 +146,11 @@ export function normalizePathPattern(p: string): string {
 export function resolve(p: string): string {
   const resolved = pathResolve(windowsPath(p))
   try {
-    return normalizePath(realpathSync(resolved))
+    const real = realpathSync(resolved)
+    if (process.platform === "win32" && isDriveLetterPath(resolved) && isUNCPath(real)) return normalizePath(resolved)
+    return normalizePath(real)
   } catch (e) {
-    if (isEnoent(e)) return normalizePath(resolved)
+    if (process.platform === "win32" || isEnoent(e)) return normalizePath(resolved)
     throw e
   }
 }

packages/opencode/src/v2/session.ts

@@ -3,6 +3,7 @@ import { SessionID } from "@/session/schema"
 import { WorkspaceID } from "@/control-plane/schema"
 import { and, asc, desc, eq, gt, gte, isNull, like, lt, or, type SQL } from "@/storage/db"
 import * as Database from "@/storage/db"
+import { realpathSync } from "fs"
 import { Context, DateTime, Effect, Layer, Option, Schema } from "effect"
 import { SessionMessage } from "./session-message"
 import type { Prompt } from "./session-prompt"
@@ -20,6 +21,17 @@ export type Delivery = Schema.Schema.Type<typeof Delivery>
 
 export const DefaultDelivery = "immediate" satisfies Delivery
 
+function directoryMatchCondition(directory: string): SQL {
+  if (process.platform !== "win32") return eq(SessionTable.directory, directory)
+  const alternatives = [directory]
+  try {
+    const real = realpathSync(directory)
+    if (real !== directory && !alternatives.includes(real)) alternatives.push(real)
+  } catch {}
+  if (alternatives.length === 1) return eq(SessionTable.directory, directory)
+  return or(...alternatives.map((d) => eq(SessionTable.directory, d)))!
+}
+
 export class Info extends Schema.Class<Info>("Session.Info")({
   id: SessionID,
   parentID: optionalOmitUndefined(SessionID),
@@ -158,7 +170,7 @@ export const layer = Layer.effect(
         if (direction === "previous" && order === "asc") order = "desc"
         if (direction === "previous" && order === "desc") order = "asc"
         const conditions: SQL[] = []
-        if (input.directory) conditions.push(eq(SessionTable.directory, input.directory))
+        if (input.directory) conditions.push(directoryMatchCondition(input.directory))
         if (input.path)
           conditions.push(or(eq(SessionTable.path, input.path), like(SessionTable.path, `${input.path}/%`))!)
         if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))

packages/opencode/test/util/filesystem.test.ts

@@ -614,7 +614,12 @@ describe("filesystem", () => {
       const b = path.join(tmp.path, "b")
       await fs.symlink(b, a)
       await fs.symlink(a, b)
-      expect(() => Filesystem.resolve(a)).toThrow()
+      if (process.platform === "win32") {
+        const result = Filesystem.resolve(a)
+        expect(typeof result).toBe("string")
+      } else {
+        expect(() => Filesystem.resolve(a)).toThrow()
+      }
     })
 
     // Windows: chmod(0o000) is a no-op, so EACCES cannot be triggered