fix: add 30s timeout to glob tool to prevent indefinite hangs (#636)

- Add `abortAfter` timeout that kills the `rg` process after 30 seconds
- Return partial results on timeout with actionable guidance message
- Fix error handling: only treat `AbortError` from timeout signal as
  timeout — properly re-throw ENOENT, permission, and user abort errors
- Add `localAbort` controller to kill `rg` process on early loop exit
  (e.g., 100-file limit hit), preventing background resource waste
- Add comprehensive glob tool tests (6 tests covering basic matching,
  truncation, user abort, nested patterns, and custom path)

Closes #636

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/tool/glob.ts

@@ -6,6 +6,9 @@ import DESCRIPTION from "./glob.txt"
 import { Ripgrep } from "../file/ripgrep"
 import { Instance } from "../project/instance"
 import { assertExternalDirectory } from "./external-directory"
+import { abortAfter } from "../util/abort"
+
+const GLOB_TIMEOUT_MS = 30_000
 
 export const GlobTool = Tool.define("glob", {
   description: DESCRIPTION,
@@ -36,29 +39,60 @@ export const GlobTool = Tool.define("glob", {
     const limit = 100
     const files = []
     let truncated = false
-    for await (const file of Ripgrep.files({
-      cwd: search,
-      glob: [params.pattern],
-      signal: ctx.abort,
-    })) {
-      if (files.length >= limit) {
-        truncated = true
-        break
+    let timedOut = false
+
+    const timeout = abortAfter(GLOB_TIMEOUT_MS)
+    const localAbort = new AbortController()
+    const parentSignals = ctx.abort ? [ctx.abort] : []
+    const signal = AbortSignal.any([timeout.signal, localAbort.signal, ...parentSignals])
+
+    try {
+      for await (const file of Ripgrep.files({
+        cwd: search,
+        glob: [params.pattern],
+        signal,
+      })) {
+        if (files.length >= limit) {
+          truncated = true
+          break
+        }
+        const full = path.resolve(search, file)
+        const stats = Filesystem.stat(full)?.mtime.getTime() ?? 0
+        files.push({
+          path: full,
+          mtime: stats,
+        })
+      }
+    } catch (err: any) {
+      if (timeout.signal.aborted) {
+        // Our timeout fired — return partial results
+        timedOut = true
+      } else {
+        // User cancellation, ENOENT, permission error, etc. — propagate
+        throw err
       }
-      const full = path.resolve(search, file)
-      const stats = Filesystem.stat(full)?.mtime.getTime() ?? 0
-      files.push({
-        path: full,
-        mtime: stats,
-      })
+    } finally {
+      localAbort.abort()
+      timeout.clearTimeout()
     }
     files.sort((a, b) => b.mtime - a.mtime)
 
     const output = []
-    if (files.length === 0) output.push("No files found")
+    if (files.length === 0 && timedOut) {
+      output.push(
+        `Glob search timed out after ${GLOB_TIMEOUT_MS / 1000}s with no results. The search directory "${search}" is too broad for the pattern "${params.pattern}". Use a more specific \`path\` parameter to narrow the search scope.`,
+      )
+    } else if (files.length === 0) {
+      output.push("No files found")
+    }
     if (files.length > 0) {
       output.push(...files.map((f) => f.path))
-      if (truncated) {
+      if (timedOut) {
+        output.push("")
+        output.push(
+          `(Search timed out after ${GLOB_TIMEOUT_MS / 1000}s: only partial results shown. Use a more specific \`path\` parameter to narrow the search scope.)`,
+        )
+      } else if (truncated) {
         output.push("")
         output.push(
           `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`,
@@ -70,7 +104,7 @@ export const GlobTool = Tool.define("glob", {
       title: path.relative(Instance.worktree, search),
       metadata: {
         count: files.length,
-        truncated,
+        truncated: truncated || timedOut,
       },
       output: output.join("\n"),
     }

packages/opencode/test/tool/glob.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import fs from "fs/promises"
+import { GlobTool } from "../../src/tool/glob"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+import { SessionID, MessageID } from "../../src/session/schema"
+
+const ctx = {
+  sessionID: SessionID.make("ses_test"),
+  messageID: MessageID.make(""),
+  callID: "",
+  agent: "build",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => {},
+  ask: async () => {},
+}
+
+describe("tool.glob", () => {
+  test("finds files matching pattern", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "a.txt"), "hello")
+        await Bun.write(path.join(dir, "b.txt"), "world")
+        await Bun.write(path.join(dir, "c.md"), "readme")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        const result = await glob.execute({ pattern: "*.txt" }, ctx)
+        expect(result.metadata.count).toBe(2)
+        expect(result.output).toContain("a.txt")
+        expect(result.output).toContain("b.txt")
+        expect(result.output).not.toContain("c.md")
+      },
+    })
+  })
+
+  test("returns 'No files found' when no matches", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        const result = await glob.execute({ pattern: "*.nonexistent" }, ctx)
+        expect(result.metadata.count).toBe(0)
+        expect(result.output).toBe("No files found")
+      },
+    })
+  })
+
+  test("truncates results at 100 files", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        for (let i = 0; i < 110; i++) {
+          await Bun.write(path.join(dir, `file${String(i).padStart(3, "0")}.txt`), "")
+        }
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        const result = await glob.execute({ pattern: "*.txt" }, ctx)
+        expect(result.metadata.count).toBe(100)
+        expect(result.metadata.truncated).toBe(true)
+        expect(result.output).toContain("Results are truncated")
+      },
+    })
+  })
+
+  test("respects user abort signal", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "a.txt"), "hello")
+      },
+    })
+    const controller = new AbortController()
+    controller.abort()
+    const abortCtx = { ...ctx, abort: controller.signal }
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        await expect(glob.execute({ pattern: "*.txt" }, abortCtx)).rejects.toThrow()
+      },
+    })
+  })
+
+  test("finds nested files with ** pattern", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await fs.mkdir(path.join(dir, "sub", "deep"), { recursive: true })
+        await Bun.write(path.join(dir, "sub", "deep", "target.yml"), "")
+        await Bun.write(path.join(dir, "other.txt"), "")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        const result = await glob.execute({ pattern: "**/target.yml" }, ctx)
+        expect(result.metadata.count).toBe(1)
+        expect(result.output).toContain("target.yml")
+      },
+    })
+  })
+
+  test("uses custom path parameter", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await fs.mkdir(path.join(dir, "subdir"))
+        await Bun.write(path.join(dir, "subdir", "inner.txt"), "")
+        await Bun.write(path.join(dir, "outer.txt"), "")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const glob = await GlobTool.init()
+        const result = await glob.execute(
+          { pattern: "*.txt", path: path.join(tmp.path, "subdir") },
+          ctx,
+        )
+        expect(result.metadata.count).toBe(1)
+        expect(result.output).toContain("inner.txt")
+        expect(result.output).not.toContain("outer.txt")
+      },
+    })
+  })
+})