fix(core): bound protected home searches

packages/cli/src/services/service-config.ts

@@ -5,7 +5,6 @@ import { Service } from "@opencode-ai/client/effect/service"
 import { Effect, FileSystem, Option, Schema } from "effect"
 import { randomBytes } from "crypto"
 import path from "path"
-import semver from "semver"
 import { selfCommand } from "../util/process"
 
 // The CLI's service configuration file, plus the Service.EnsureOptions binding that
@@ -105,21 +104,10 @@ export const options = Effect.fnUntraced(function* () {
   return {
     file,
     version: OPENCODE_VERSION,
-    canReplace: (version: string | undefined) => canReplaceVersion(version),
     command: [...selfCommand(), "serve", "--service"],
   }
 })
 
-export function canReplaceVersion(serverVersion: string | undefined, clientVersion = OPENCODE_VERSION) {
-  if (serverVersion === undefined) return true
-  // Preview versions end in `<channel>-<build>[.<attempt>]`. Convert the build
-  // to a numeric semver identifier so next-15000 sorts after next-9999.
-  const server = serverVersion.replace(/-(\d+)(?=(?:\.\d+)?$)/, ".$1")
-  const client = clientVersion.replace(/-(\d+)(?=(?:\.\d+)?$)/, ".$1")
-  if (!semver.valid(server) || !semver.valid(client)) return true
-  return semver.lt(server, client)
-}
-
 export const read = Effect.fn("cli.service-config.read")(function* () {
   const { fs, configFile, legacyConfigFile } = yield* paths
   if (legacyConfigFile) yield* migrateConfig(legacyConfigFile, configFile)

packages/cli/test/service.test.ts

@@ -47,15 +47,6 @@ test("service filenames share release channels and identify preview channels", (
   expect(ServiceConfig.versionBelongsToChannel("1.2.3", "preview-a")).toBe(false)
 })
 
-test("only newer clients replace managed service versions", () => {
-  expect(ServiceConfig.canReplaceVersion("1.2.3", "1.2.4")).toBe(true)
-  expect(ServiceConfig.canReplaceVersion("1.2.4", "1.2.3")).toBe(false)
-  expect(ServiceConfig.canReplaceVersion("1.2.3", "1.2.3")).toBe(false)
-  expect(ServiceConfig.canReplaceVersion("0.0.0-next-9999", "0.0.0-next-15000")).toBe(true)
-  expect(ServiceConfig.canReplaceVersion("0.0.0-next-15000", "0.0.0-next-9999")).toBe(false)
-  expect(ServiceConfig.canReplaceVersion(undefined, "1.2.3")).toBe(true)
-})
-
 test("service config migrates from the hashed channel filename", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-config-migration-"))
   const legacy = path.join(root, ServiceConfig.legacyFilename("preview-a")!)

packages/client/src/effect/service.ts

@@ -3,13 +3,7 @@ import { Effect, FileSystem, Option, Schedule, Schema } from "effect"
 import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
-import {
-  VersionMismatchError,
-  type DiscoverOptions,
-  type Endpoint,
-  type EnsureOptions,
-  type StopOptions,
-} from "../service.js"
+import type { DiscoverOptions, Endpoint, EnsureOptions, StopOptions } from "../service.js"
 
 export * from "../service.js"
 /** Contents of the local service registration file. */
@@ -62,6 +56,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
+  let ownerHeld = false
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) =>
     Effect.sync(() => {
       if (announced) return
@@ -89,27 +84,27 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     const info = registration.info
     const service = registration.service
     if (service !== undefined) {
+      ownerHeld = false
       spawnDelay = 5_000
       const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
       if (compatible && service.state === "ready") return Option.some(service)
       if (compatible && service.state === "failed")
         return yield* Effect.fail(new Error("Background service failed to start"))
       if (compatible) return Option.none<LocalService>()
-      if (options.canReplace?.(service.version) === false)
-        return yield* Effect.fail(new VersionMismatchError(options.version, service.version))
       yield* announce("version-mismatch", service.version)
       yield* kill(service, options).pipe(Effect.ignore)
       lastSpawn = 0
       return Option.none<LocalService>()
     } else if (lastSpawn === 0 && info !== undefined) lastSpawn = Date.now()
 
+    const failure = [...contenders].map(contenderFailure).find((error): error is Error => error !== undefined)
+    if (failure !== undefined) return yield* Effect.fail(failure)
     const finished = [...contenders].filter(contenderFinished)
-    const failure = finished.map(contenderFailure).find((error): error is Error => error !== undefined)
     if (finished.some((item) => item.child.exitCode === 0)) {
+      ownerHeld = true
       spawnDelay = Math.min(spawnDelay * 2, 30_000)
     }
     finished.forEach((item) => contenders.delete(item))
-    if (failure !== undefined && contenders.size === 0) return yield* Effect.fail(failure)
     // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
     if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
       yield* announce("missing")

packages/client/src/promise/service.ts

@@ -2,14 +2,7 @@ import { readFile } from "node:fs/promises"
 import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
-import {
-  VersionMismatchError,
-  type DiscoverOptions,
-  type Endpoint,
-  type Info,
-  type EnsureOptions,
-  type StopOptions,
-} from "../service.js"
+import type { DiscoverOptions, Endpoint, Info, EnsureOptions, StopOptions } from "../service.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"
 
 export * from "../service.js"
@@ -44,6 +37,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
+  let ownerHeld = false
 
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) => {
     if (announced) return
@@ -71,27 +65,27 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
     const registration = await registered(options.file, true)
 
     if (registration.service !== undefined) {
+      ownerHeld = false
       spawnDelay = 5_000
       const service = registration.service
       const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
       if (compatible && service.state === "ready") return service.endpoint
       if (compatible && service.state === "failed") throw new Error("Background service failed to start")
       if (!compatible) {
-        if (options.canReplace?.(service.version) === false)
-          throw new VersionMismatchError(options.version, service.version)
         announce("version-mismatch", service.version)
         await kill(service, options).catch(() => undefined)
         lastSpawn = 0
       }
     } else {
       if (lastSpawn === 0 && registration.info !== undefined) lastSpawn = Date.now()
+      const failure = [...contenders].map(contenderFailure).find((error) => error !== undefined)
+      if (failure !== undefined) throw failure
       const finished = [...contenders].filter(contenderFinished)
-      const failure = finished.map(contenderFailure).find((error) => error !== undefined)
       if (finished.some((item) => item.child.exitCode === 0)) {
+        ownerHeld = true
         spawnDelay = Math.min(spawnDelay * 2, 30_000)
       }
       finished.forEach((item) => contenders.delete(item))
-      if (failure !== undefined && contenders.size === 0) throw failure
       // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
       if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
         announce("missing")

packages/client/src/service.ts

@@ -28,24 +28,10 @@ export type EnsureReason = "missing" | "version-mismatch"
 export type EnsureOptions = DiscoverOptions & {
   /** Service command and arguments. Defaults to `opencode serve --service`. */
   readonly command?: ReadonlyArray<string>
-  /** Decide whether a version-mismatched service may be replaced. Defaults to true. */
-  readonly canReplace?: (version: string | undefined) => boolean
   /** Called once before spawning a new service process. */
   readonly onStart?: (reason: EnsureReason, previousVersion?: string) => void
 }
 
-/** A healthy service exists, but the caller's replacement policy protects it. */
-export class VersionMismatchError extends Error {
-  override readonly name = "VersionMismatchError"
-
-  constructor(
-    readonly clientVersion: string | undefined,
-    readonly serverVersion: string | undefined,
-  ) {
-    super(`Client version ${clientVersion ?? "unknown"} cannot replace server version ${serverVersion ?? "unknown"}`)
-  }
-}
-
 /** Options used to stop the local OpenCode service. */
 export type StopOptions = {
   /** Absolute registration file path. Defaults to the XDG state directory. */

packages/client/test/fixture/service.ts

@@ -9,20 +9,14 @@ if (mode === "record-start") {
 }
 if (mode === "signal") process.kill(process.pid, process.platform === "win32" ? "SIGTERM" : "SIGKILL")
 
-if (
-  mode === "delayed" ||
-  mode === "delayed-failed" ||
-  mode === "coordinated" ||
-  mode === "coordinated-failed-loser"
-) {
+if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated") {
   await appendFile(registration + ".starts", process.pid + "\n")
   const owner = await writeFile(registration + ".owner", String(process.pid), { flag: "wx" })
     .then(() => true)
     .catch(() => false)
-  if (!owner) process.exit(mode === "coordinated-failed-loser" ? 1 : 0)
-  if (mode === "coordinated" || mode === "coordinated-failed-loser") {
+  if (!owner) process.exit()
+  if (mode === "coordinated") {
     while ((await Bun.file(registration + ".starts").text()).trim().split("\n").length < 2) await Bun.sleep(10)
-    if (mode === "coordinated-failed-loser") await Bun.sleep(1_500)
   } else await Bun.sleep(Number(delay))
   if (mode === "delayed-failed") process.exit(1)
 }

packages/client/test/promise-service.test.ts

@@ -44,24 +44,6 @@ test("ensures a missing service with native promises", async () => {
   }
 }, 15_000)
 
-test("waits for a live contender when another native contender fails", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-
-  const endpoint = await Service.ensure({
-    file: registration,
-    version: "test",
-    command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
-  })
-  const info = await Bun.file(registration).json()
-  try {
-    expect(endpoint.url).toBe(info.url)
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-}, 15_000)
-
 test("reports a failed registered service", async () => {
   const registration = await setup("failed-owner")
 
@@ -70,25 +52,6 @@ test("reports a failed registered service", async () => {
   )
 })
 
-test("does not replace a version rejected by the caller", async () => {
-  const registration = await setup("graceful")
-  const directory = await temp()
-  const contender = join(directory, "contender.json")
-  const info = await Bun.file(registration).json()
-
-  await expect(
-    Service.ensure({
-      file: registration,
-      version: "old",
-      canReplace: () => false,
-      command: [process.execPath, fixture, contender, "record-start"],
-    }),
-  ).rejects.toThrow("Client version old cannot replace server version test")
-
-  expect(await Bun.file(contender + ".started").exists()).toBe(false)
-  expect(process.kill(info.pid, 0)).toBe(true)
-})
-
 test("requests graceful stop of the exact service instance", async () => {
   const registration = await setup("graceful")
   const info = await Bun.file(registration).json()

packages/client/test/service.test.ts

@@ -107,28 +107,6 @@ test("does not spawn contenders while an incompatible service rejects replacemen
   expect(existing.exitCode).toBe(null)
 })
 
-test("does not replace a version rejected by the caller", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const contender = join(directory, "contender.json")
-  const existing = spawn(registration, "graceful")
-  await waitForFile(registration)
-
-  await expect(
-    run(
-      Service.ensure({
-        file: registration,
-        version: "old",
-        canReplace: () => false,
-        command: [process.execPath, fixture, contender, "record-start"],
-      }),
-    ),
-  ).rejects.toThrow("Client version old cannot replace server version test")
-
-  expect(await Bun.file(contender + ".started").exists()).toBe(false)
-  expect(existing.exitCode).toBe(null)
-})
-
 test("a legacy health response is still replaced", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
@@ -163,24 +141,6 @@ test("waits for a slow winner while bounding lock probes", async () => {
   }
 }, 15_000)
 
-test("waits for a live contender when another contender fails", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await run(
-    Service.ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
-    }),
-  )
-  const info = await Bun.file(registration).json()
-  try {
-    expect(endpoint.url).toBe(info.url)
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-  }
-}, 15_000)
-
 test("reports a contender that fails to start", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/core/src/filesystem/location-watcher.ts

@@ -3,7 +3,6 @@ export * as LocationWatcher from "./location-watcher"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, Effect, Layer, Stream } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
-import os from "os"
 import path from "path"
 import { Config } from "../config"
 import { Bus } from "../bus"
@@ -44,7 +43,7 @@ const layer = Layer.effect(
       const config = (yield* configService.entries())
         .filter((entry): entry is Config.Document => entry.type === "document")
         .flatMap((item) => item.info.watcher?.ignore ?? [])
-      const home = path.resolve(location.directory) === path.resolve(os.homedir())
+      const home = Protected.isHome(location.directory)
 
       if (!home && location.vcs) {
         const updates = yield* watcher.subscribe({

packages/core/src/filesystem/protected.ts

@@ -3,6 +3,10 @@ import path from "path"
 
 const home = os.homedir()
 
+export function isHome(directory: string) {
+  return path.resolve(directory) === path.resolve(home)
+}
+
 const DARWIN_HOME = [
   "Music",
   "Pictures",

packages/core/src/filesystem/search.ts

@@ -10,6 +10,7 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../location"
 import { Ripgrep } from "../ripgrep"
 import { RelativePath } from "../schema"
+import { Protected } from "./protected"
 
 export interface Interface {
   readonly find: (input: FileSystem.FindInput) => Effect.Effect<FileSystem.Entry[]>
@@ -33,20 +34,22 @@ export const ripgrepLayer = Layer.effect(
     const scope = yield* Scope.Scope
     const state = {
       files: [] as string[],
-      directories: [] as string[],
+      directories: new Set<string>(),
     }
-    const directories = new Set<string>()
+    const home = Protected.isHome(location.directory)
     yield* ripgrep
       .find({
         cwd: location.directory,
         pattern: "*",
-        limit: location.vcs ? Number.MAX_SAFE_INTEGER : 100_000,
+        limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 100_000,
+        exclude: home ? [...Protected.names()].map((name) => `${name}/**`) : undefined,
         onEntry: (entry) =>
           Effect.sync(() => {
             state.files.push(entry.path)
             const parts = entry.path.split("/")
-            parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path.sep))
-            state.directories = Array.from(directories)
+            parts
+              .slice(0, -1)
+              .forEach((_, index) => state.directories.add(parts.slice(0, index + 1).join("/") + path.sep))
           }),
       })
       .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
@@ -104,12 +107,13 @@ export const ripgrepLayer = Layer.effect(
         }),
       find: (input) =>
         Effect.gen(function* () {
+          const directories = Array.from(state.directories)
           const items =
             input.type === "file"
               ? state.files
               : input.type === "directory"
-                ? state.directories
-                : [...state.files, ...state.directories]
+                ? directories
+                : [...state.files, ...directories]
           return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
             const relative = item.target
             const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)
@@ -236,15 +240,16 @@ export const fffLayer = Layer.effect(
   }),
 )
 
-export const layer = (options?: Options) => Layer.unwrap(
-  Effect.gen(function* () {
-    if (options?.fff === false || (options?.fff === undefined && process.platform === "win32") || !Fff.available())
-      return ripgrepLayer
-    const location = yield* Location.Service
-    // Non-VCS locations can contain many repositories, so avoid eagerly content-indexing the entire aggregate tree.
-    return location.vcs ? fffLayer : ripgrepLayer
-  }),
-)
+export const layer = (options?: Options) =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      if (options?.fff === false || (options?.fff === undefined && process.platform === "win32") || !Fff.available())
+        return ripgrepLayer
+      const location = yield* Location.Service
+      // Non-VCS locations can contain many repositories, so avoid eagerly content-indexing the entire aggregate tree.
+      return location.vcs && !Protected.isHome(location.directory) ? fffLayer : ripgrepLayer
+    }),
+  )
 
 export function configured(options?: Options) {
   return makeLocationNode({ service: Service, layer: layer(options), deps: [FSUtil.node, Location.node, Ripgrep.node] })

packages/core/src/ripgrep.ts

@@ -52,6 +52,7 @@ export interface FindInput {
   readonly cwd: string
   readonly pattern: string
   readonly limit: number
+  readonly exclude?: readonly string[]
   readonly hidden?: boolean
   readonly follow?: boolean
   readonly signal?: AbortSignal
@@ -195,6 +196,7 @@ const layer = Layer.effect(
             ...(input.hidden ? ["--hidden"] : []),
             ...(input.follow ? ["--follow"] : []),
             ...(input.pattern === "*" ? [] : [`--glob=${input.pattern}`]),
+            ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
             "--glob=!**/.git/**",
             ".",
           ],

packages/core/test/filesystem/search.test.ts

@@ -1,10 +1,17 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import fs from "fs/promises"
+import os from "os"
 import path from "path"
-import { Effect } from "effect"
+import { Effect, Layer } from "effect"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { FileSystem } from "@opencode-ai/core/filesystem"
+import { Protected } from "@opencode-ai/core/filesystem/protected"
+import { FileSystemSearch } from "@opencode-ai/core/filesystem/search"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { Location } from "@opencode-ai/core/location"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
+import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 
@@ -42,3 +49,50 @@ describe("Ripgrep", () => {
     ),
   )
 })
+
+describe("FileSystemSearch", () => {
+  test("bounds a home scan even when home is detected as a repository", async () => {
+    let observed: Ripgrep.FindInput | undefined
+    const home = AbsolutePath.make(os.homedir())
+    const layer = AppNodeBuilder.build(FileSystemSearch.node, [
+      [
+        Location.node,
+        Layer.succeed(
+          Location.Service,
+          Location.Service.of(
+            location({ directory: home }, { vcs: { type: "git", store: AbsolutePath.make(path.join(home, ".git")) } }),
+          ),
+        ),
+      ],
+      [
+        Ripgrep.node,
+        Layer.succeed(
+          Ripgrep.Service,
+          Ripgrep.Service.of({
+            find: (input) =>
+              Effect.gen(function* () {
+                observed = input
+                if (input.onEntry)
+                  yield* input.onEntry(FileSystem.Entry.make({ path: RelativePath.make("src/index.ts"), type: "file" }))
+                return []
+              }),
+            glob: () => Effect.succeed([]),
+            grep: () => Effect.succeed([]),
+          }),
+        ),
+      ],
+    ])
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const search = yield* FileSystemSearch.Service
+        yield* Effect.sleep("10 millis")
+        expect(observed?.limit).toBe(100_000)
+        expect(observed?.exclude).toEqual([...Protected.names()].map((name) => `${name}/**`))
+        expect((yield* search.find({ query: "src", type: "directory" }))[0]?.path).toBe(
+          RelativePath.make(`src${path.sep}`),
+        )
+      }).pipe(Effect.provide(layer), Effect.scoped),
+    )
+  })
+})

packages/core/test/ripgrep.test.ts

@@ -63,6 +63,29 @@ describe("Ripgrep", () => {
     ),
   )
 
+  it.live("excludes protected directory trees from catch-all find results", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "Pictures")))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "Pictures", "private.jpg"), "private\n"))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "visible.txt"), "visible\n"))
+
+          const files = yield* (yield* Ripgrep.Service).find({
+            cwd: tmp.path,
+            pattern: "*",
+            limit: 10,
+            exclude: ["Pictures/**"],
+          })
+
+          expect(files.map((item) => item.path)).toContain(RelativePath.make("visible.txt"))
+          expect(files.map((item) => item.path)).not.toContain(RelativePath.make("Pictures/private.jpg"))
+        }),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
+  )
+
   it.live("returns a bounded preview for matches on oversized lines", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),