@rama_nigg/open-cursor 2.3.20 → 2.4.0

package/src/plugin.ts

@@ -10,7 +10,12 @@ import { startCursorOAuth } from "./auth";
 import { LineBuffer } from "./streaming/line-buffer.js";
 import { StreamToSseConverter, formatSseDone } from "./streaming/openai-sse.js";
 import { parseStreamJsonLine } from "./streaming/parser.js";
-import { extractText, extractThinking, isAssistantText, isThinking } from "./streaming/types.js";
+import { extractText, extractThinking, isAssistantText, isResult, isThinking } from "./streaming/types.js";
+import {
+  createChatCompletionUsageChunk,
+  extractOpenAiUsageFromResult,
+  type OpenAiUsage,
+} from "./usage.js";
 import { createLogger } from "./utils/logger";
 import { RequestPerf } from "./utils/perf";
 import { parseAgentError, formatErrorForUser, stripAnsi } from "./utils/errors";
@@ -52,6 +57,7 @@ import {
   parseToolLoopMaxRepeat,
   type ToolLoopGuard,
 } from "./provider/tool-loop-guard.js";
+import { resolveCursorAgentBinary } from "./utils/binary.js";
 
 const log = createLogger("plugin");
 
@@ -191,7 +197,7 @@ function canonicalizePathForCompare(pathValue: string): string {
     normalizedPath = resolvedPath;
   }
 
-  if (process.platform === "darwin") {
+  if (process.platform === "darwin" || process.platform === "win32") {
     return normalizedPath.toLowerCase();
   }
 
@@ -219,37 +225,76 @@ function isNonConfigPath(pathValue: string): boolean {
   return !isWithinPath(getOpenCodeConfigPrefix(), pathValue);
 }
 
-const SESSION_WORKSPACE_CACHE_LIMIT = 200;
-
-function resolveWorkspaceDirectory(worktree: string | undefined, directory: string | undefined): string {
-  const envWorkspace = process.env.CURSOR_ACP_WORKSPACE?.trim();
-  if (envWorkspace) {
-    return resolve(envWorkspace);
+// Filesystem roots are never a meaningful workspace: accepting "/" (or a bare
+// Windows drive root like "C:\") makes every tool treat the whole machine as
+// the project, which is both unsafe and a common symptom of a daemon that
+// was launched without a real cwd (e.g. systemd unit without WorkingDirectory).
+export function isRootPath(pathValue: string): boolean {
+  if (!pathValue) {
+    return false;
   }
+  const resolved = resolve(pathValue);
+  if (resolved === "/") {
+    return true;
+  }
+  return /^[A-Za-z]:[\\/]?$/.test(resolved);
+}
 
-  const envProjectDir = process.env.OPENCODE_CURSOR_PROJECT_DIR?.trim();
-  if (envProjectDir) {
-    return resolve(envProjectDir);
+function isAcceptableWorkspace(pathValue: string, configPrefix: string): boolean {
+  if (!pathValue) {
+    return false;
   }
+  if (isRootPath(pathValue)) {
+    return false;
+  }
+  if (isWithinPath(configPrefix, pathValue)) {
+    return false;
+  }
+  return true;
+}
+
+const SESSION_WORKSPACE_CACHE_LIMIT = 200;
 
+export function resolveWorkspaceDirectory(
+  worktree: string | undefined,
+  directory: string | undefined,
+): string {
   const configPrefix = getOpenCodeConfigPrefix();
 
+  const envWorkspace = resolveCandidate(process.env.CURSOR_ACP_WORKSPACE);
+  if (envWorkspace && !isRootPath(envWorkspace)) {
+    return envWorkspace;
+  }
+
+  const envProjectDir = resolveCandidate(process.env.OPENCODE_CURSOR_PROJECT_DIR);
+  if (envProjectDir && !isRootPath(envProjectDir)) {
+    return envProjectDir;
+  }
+
   const worktreeCandidate = resolveCandidate(worktree);
-  if (worktreeCandidate && !isWithinPath(configPrefix, worktreeCandidate)) {
+  if (isAcceptableWorkspace(worktreeCandidate, configPrefix)) {
     return worktreeCandidate;
   }
 
   const dirCandidate = resolveCandidate(directory);
-  if (dirCandidate && !isWithinPath(configPrefix, dirCandidate)) {
+  if (isAcceptableWorkspace(dirCandidate, configPrefix)) {
     return dirCandidate;
   }
 
   const cwd = resolve(process.cwd());
-  if (cwd && !isWithinPath(configPrefix, cwd)) {
+  if (isAcceptableWorkspace(cwd, configPrefix)) {
     return cwd;
   }
 
-  return dirCandidate || cwd || configPrefix;
+  // Fall back to the user's home directory rather than "/" when every other
+  // signal is unusable. $HOME is always writable for the current user and
+  // keeps tool scopes sane even when the daemon was spawned from root.
+  const home = resolveCandidate(homedir());
+  if (home && !isRootPath(home)) {
+    return home;
+  }
+
+  return configPrefix;
 }
 
 type ProxyRuntimeState = {
@@ -258,7 +303,11 @@ type ProxyRuntimeState = {
 };
 
 export function normalizeWorkspaceForCompare(pathValue: string): string {
-  return resolve(pathValue);
+  const resolved = resolve(pathValue);
+  if (process.platform === "darwin" || process.platform === "win32") {
+    return resolved.toLowerCase();
+  }
+  return resolved;
 }
 
 export function isReusableProxyHealthPayload(payload: any, workspaceDirectory: string): boolean {
@@ -321,7 +370,12 @@ export function resolveChatParamTools(
   return PROVIDER_BOUNDARY.resolveChatParamTools(mode, existingTools, refreshedTools);
 }
 
-function createChatCompletionResponse(model: string, content: string, reasoningContent?: string) {
+function createChatCompletionResponse(
+  model: string,
+  content: string,
+  reasoningContent?: string,
+  usage?: OpenAiUsage,
+) {
   const message: { role: "assistant"; content: string; reasoning_content?: string } = {
     role: "assistant",
     content,
@@ -331,7 +385,18 @@ function createChatCompletionResponse(model: string, content: string, reasoningC
     message.reasoning_content = reasoningContent;
   }
 
-  return {
+  const response: {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+      index: number;
+      message: typeof message;
+      finish_reason: string;
+    }>;
+    usage?: OpenAiUsage;
+  } = {
     id: `cursor-acp-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
@@ -344,6 +409,12 @@ function createChatCompletionResponse(model: string, content: string, reasoningC
       },
     ],
   };
+
+  if (usage) {
+    response.usage = usage;
+  }
+
+  return response;
 }
 
 function createChatCompletionChunk(id: string, created: number, model: string, deltaContent: string, done = false) {
@@ -362,11 +433,17 @@ function createChatCompletionChunk(id: string, created: number, model: string, d
   };
 }
 
-function extractCompletionFromStream(output: string): { assistantText: string; reasoningText: string } {
+export function extractCompletionFromStream(output: string): {
+  assistantText: string;
+  reasoningText: string;
+  usage?: OpenAiUsage;
+} {
   const lines = output.split("\n");
   let assistantText = "";
   let reasoningText = "";
+  let usage: OpenAiUsage | undefined;
   let sawAssistantPartials = false;
+  let sawThinkingPartials = false;
 
   for (const line of lines) {
     const event = parseStreamJsonLine(line);
@@ -390,12 +467,22 @@ function extractCompletionFromStream(output: string): { assistantText: string; r
     if (isThinking(event)) {
       const thinking = extractThinking(event);
       if (thinking) {
-        reasoningText += thinking;
+        const isPartial = typeof (event as any).timestamp_ms === "number";
+        if (isPartial) {
+          reasoningText += thinking;
+          sawThinkingPartials = true;
+        } else if (!sawThinkingPartials) {
+          reasoningText = thinking;
+        }
       }
     }
+
+    if (isResult(event)) {
+      usage = extractOpenAiUsageFromResult(event) ?? usage;
+    }
   }
 
-  return { assistantText, reasoningText };
+  return { assistantText, reasoningText, usage };
 }
 
 function formatToolUpdateEvent(update: ToolUpdate): string {
@@ -570,7 +657,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       if (url.pathname === "/v1/models" || url.pathname === "/models") {
         try {
           const bunAny = globalThis as any;
-          const proc = bunAny.Bun.spawn(["cursor-agent", "models"], {
+          const proc = bunAny.Bun.spawn([resolveCursorAgentBinary(), "models"], {
             stdout: "pipe",
             stderr: "pipe",
           });
@@ -621,6 +708,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       // DEBUG: Log raw request structure for tool-loop investigation
       debugLogToFile("raw_request_body", {
         model: body?.model,
+        cursorModel: body?.cursorModel,
         stream,
         toolCount: tools.length,
         toolNames: tools.map((t: any) => t?.function?.name ?? t?.name ?? "unknown"),
@@ -637,8 +725,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
       const subagentNames = readSubagentNames();
       const prompt = buildPromptFromMessages(messages, tools, subagentNames);
-      const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
-        boundary.normalizeRuntimeModel(body?.model),
+      const model = boundaryContext.run("resolveRuntimeModel", (boundary) =>
+        boundary.resolveRuntimeModel(body?.model, body?.cursorModel),
       );
       const msgSummaryBun = messages.map((m: any, i: number) => {
         const role = m?.role ?? "?";
@@ -664,7 +752,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       }
 
       const cmd = [
-        "cursor-agent",
+        resolveCursorAgentBinary(),
         "--print",
         "--output-format",
         "stream-json",
@@ -765,6 +853,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
           model,
           completion.assistantText || stdout || stderr,
           completion.reasoningText || undefined,
+          completion.usage,
         );
         return new Response(JSON.stringify(payload), {
           status: 200,
@@ -786,6 +875,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         async start(controller) {
           let streamTerminated = false;
           let firstTokenReceived = false;
+          let usage: OpenAiUsage | undefined;
           try {
             const reader = (child.stdout as ReadableStream<Uint8Array>).getReader();
             const converter = new StreamToSseConverter(model, { id, created });
@@ -840,6 +930,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
                   continue;
                 }
 
+                if (isResult(event)) {
+                  usage = extractOpenAiUsageFromResult(event) ?? usage;
+                }
+
                 if (event.type === "tool_call") {
                   perf.mark("tool-call");
                   const result = await handleToolLoopEventWithFallback({
@@ -906,6 +1000,9 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               if (!event) {
                 continue;
               }
+              if (isResult(event)) {
+                usage = extractOpenAiUsageFromResult(event) ?? usage;
+              }
               if (event.type === "tool_call") {
                 const result = await handleToolLoopEventWithFallback({
                   event: event as any,
@@ -994,6 +1091,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunk)}\n\n`));
+            if (usage) {
+              const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(usageChunk)}\n\n`));
+            }
             controller.enqueue(encoder.encode(formatSseDone()));
           } finally {
             perf.mark("request:done");
@@ -1054,8 +1155,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       // Dynamic model discovery via cursor-agent models (Node.js handler)
       if (url.pathname === "/v1/models" || url.pathname === "/models") {
         try {
-          const { execSync } = await import("child_process");
-          const output = execSync("cursor-agent models", { encoding: "utf-8", timeout: 30000 });
+          const { execFileSync } = await import("child_process");
+          const output = execFileSync(resolveCursorAgentBinary(), ["models"], { encoding: "utf-8", timeout: 30000 });
           const clean = stripAnsi(output);
           const models: Array<{ id: string; object: string; created: number; owned_by: string }> = [];
           for (const line of clean.split("\n")) {
@@ -1102,8 +1203,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
       const subagentNames = readSubagentNames();
       const prompt = buildPromptFromMessages(messages, tools, subagentNames);
-      const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
-        boundary.normalizeRuntimeModel(bodyData?.model),
+      const model = boundaryContext.run("resolveRuntimeModel", (boundary) =>
+        boundary.resolveRuntimeModel(bodyData?.model, bodyData?.cursorModel),
       );
       const msgSummary = messages.map((m: any, i: number) => {
         const role = m?.role ?? "?";
@@ -1123,7 +1224,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       });
 
       const cmd = [
-        "cursor-agent",
+        resolveCursorAgentBinary(),
         "--print",
         "--output-format",
         "stream-json",
@@ -1137,7 +1238,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         cmd.push("--force");
       }
 
-      const child = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "pipe", "pipe"] });
+      const child = spawn(cmd[0], cmd.slice(1), {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: process.platform === "win32",
+      });
 
       // Write prompt to stdin to avoid E2BIG error
       child.stdin.write(prompt);
@@ -1225,6 +1329,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
             model,
             completion.assistantText || stdout || stderr,
             completion.reasoningText || undefined,
+            completion.usage,
           );
 
           res.writeHead(200, { "Content-Type": "application/json" });
@@ -1251,6 +1356,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         const stderrChunks: Buffer[] = [];
         let streamTerminated = false;
         let firstTokenReceived = false;
+        let usage: OpenAiUsage | undefined;
         child.stderr.on("data", (chunk) => {
           stderrChunks.push(Buffer.from(chunk));
         });
@@ -1323,6 +1429,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               continue;
             }
 
+            if (isResult(event)) {
+              usage = extractOpenAiUsageFromResult(event) ?? usage;
+            }
+
             if (event.type === "tool_call") {
               perf.mark("tool-call");
               const result = await handleToolLoopEventWithFallback({
@@ -1395,6 +1505,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               continue;
             }
 
+            if (isResult(event)) {
+              usage = extractOpenAiUsageFromResult(event) ?? usage;
+            }
+
             if (event.type === "tool_call") {
               const result = await handleToolLoopEventWithFallback({
                 event: event as any,
@@ -1499,6 +1613,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
             ],
           };
           res.write(`data: ${JSON.stringify(doneChunk)}\n\n`);
+          if (usage) {
+            const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
+            res.write(`data: ${JSON.stringify(usageChunk)}\n\n`);
+          }
           res.write(formatSseDone());
           res.end();
         });
@@ -1594,7 +1712,7 @@ function jsonSchemaToZod(jsonSchema: any): any {
         }
         break;
       case "object":
-        zodType = z.record(z.any());
+        zodType = z.record(z.string(), z.any());
         if (p.description) {
           zodType = zodType.describe(p.description);
         }

package/src/provider/boundary.ts

@@ -36,6 +36,7 @@ export interface ProviderBoundary {
   ): ToolLoopFlags;
   matchesProvider(inputModel: any): boolean;
   normalizeRuntimeModel(model: unknown): string;
+  resolveRuntimeModel(model: unknown, cursorModel: unknown): string;
   applyChatParamDefaults(
     output: any,
     proxyBaseURL: string | undefined,
@@ -137,6 +138,15 @@ function createSharedBoundary(
       return raw;
     },
 
+    resolveRuntimeModel(model, cursorModel) {
+      const rawCursorModel = typeof cursorModel === "string" ? cursorModel.trim() : "";
+      if (rawCursorModel.length > 0) {
+        return this.normalizeRuntimeModel(rawCursorModel);
+      }
+
+      return this.normalizeRuntimeModel(model);
+    },
+
     applyChatParamDefaults(output, proxyBaseURL, defaultBaseURL, defaultApiKey) {
       output.options = output.options || {};
       output.options.baseURL = proxyBaseURL || defaultBaseURL;

package/src/proxy/formatter.ts

@@ -1,5 +1,22 @@
-export function createChatCompletionResponse(model: string, content: string) {
-  return {
+import type { OpenAiUsage } from "../usage.js";
+
+export function createChatCompletionResponse(
+  model: string,
+  content: string,
+  usage?: OpenAiUsage,
+) {
+  const response: {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+      index: number;
+      message: { role: string; content: string };
+      finish_reason: string;
+    }>;
+    usage?: OpenAiUsage;
+  } = {
     id: `cursor-acp-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
@@ -8,15 +25,16 @@ export function createChatCompletionResponse(model: string, content: string) {
       {
         index: 0,
         message: { role: "assistant", content },
-        finish_reason: "stop"
+        finish_reason: "stop",
       }
     ],
-    usage: {
-      prompt_tokens: 0,
-      completion_tokens: 0,
-      total_tokens: 0
-    }
   };
+
+  if (usage) {
+    response.usage = usage;
+  }
+
+  return response;
 }
 
 export function createChatCompletionChunk(
@@ -24,7 +42,7 @@ export function createChatCompletionChunk(
   created: number,
   model: string,
   deltaContent: string,
-  done = false
+  done = false,
 ) {
   return {
     id,
@@ -35,8 +53,8 @@ export function createChatCompletionChunk(
       {
         index: 0,
         delta: deltaContent ? { content: deltaContent } : {},
-        finish_reason: done ? "stop" : null
+        finish_reason: done ? "stop" : null,
       }
-    ]
+    ],
   };
-}
+}

package/src/streaming/types.ts

@@ -75,8 +75,13 @@ export type StreamJsonResultEvent = {
   type: "result";
   subtype?: "success" | "error" | string;
   timestamp?: number;
+  duration_ms?: number;
+  duration_api_ms?: number;
   session_id?: string;
+  request_id?: string;
+  result?: string;
   is_error?: boolean;
+  usage?: Record<string, unknown>;
   error?: {
     message?: string;
     code?: number | string;

package/src/tools/defaults.ts

@@ -1,4 +1,5 @@
 import type { ToolRegistry } from "./core/registry.js";
+import { createLogger } from "../utils/logger.js";
 
 /**
  * Register default OpenCode tools in the registry
@@ -265,6 +266,10 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     const path = args.path as string;
     const include = args.include as string | undefined;
 
+    if (process.platform === "win32") {
+      return nodeFallbackGrep(pattern, path, include);
+    }
+
     const grepArgs = ["-r", "-n"];
     if (include) {
       grepArgs.push(`--include=${include}`);
@@ -374,6 +379,11 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     const path = resolvePathArg(args, "glob");
     const cwd = path || ".";
     const normalizedPattern = pattern.replace(/\\/g, "/");
+
+    if (process.platform === "win32") {
+      return nodeFallbackGlob(normalizedPattern, cwd);
+    }
+
     const isPathPattern = normalizedPattern.includes("/");
     const findArgs = [cwd, "-type", "f"];
     if (isPathPattern) {
@@ -703,3 +713,159 @@ function coerceToString(value: unknown): string | null {
 export function getDefaultToolNames(): string[] {
   return ["bash", "read", "write", "edit", "grep", "ls", "glob", "mkdir", "rm", "stat"];
 }
+
+const FALLBACK_SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build"]);
+const fallbackLog = createLogger("tools:fallback");
+
+export async function nodeFallbackGrep(
+  pattern: string,
+  searchPath: string,
+  include?: string,
+): Promise<string> {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+
+  let regex: RegExp;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    return "Invalid regex pattern";
+  }
+
+  let includeRegex: RegExp | undefined;
+  if (include) {
+    const incPattern = include.replace(/\./g, "\\.").replace(/\?/g, ".").replace(/\*/g, ".*");
+    includeRegex = new RegExp(`^${incPattern}$`);
+  }
+
+  const results: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    if (results.length >= 100) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading directory", { dir, code: err?.code, message: err?.message });
+      }
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 100) return;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!FALLBACK_SKIP_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (includeRegex && !includeRegex.test(entry.name)) continue;
+        let content: string;
+        try {
+          content = await fs.readFile(fullPath, "utf-8");
+        } catch (err: any) {
+          if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+            fallbackLog.error("Unexpected error reading file", { path: fullPath, code: err?.code, message: err?.message });
+          }
+          continue;
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push(`${fullPath}:${i + 1}:${lines[i]}`);
+            if (results.length >= 100) break;
+          }
+        }
+      }
+    }
+  }
+
+  let stat;
+  try {
+    stat = await fs.stat(searchPath);
+  } catch {
+    return "Path not found";
+  }
+
+  if (stat.isFile()) {
+    let content: string;
+    try {
+      content = await fs.readFile(searchPath, "utf-8");
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading file", { path: searchPath, code: err?.code, message: err?.message });
+      }
+      return "Path not found";
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        results.push(`${searchPath}:${i + 1}:${lines[i]}`);
+        if (results.length >= 100) break;
+      }
+    }
+  } else {
+    await walk(searchPath);
+  }
+
+  return results.join("\n") || "No matches found";
+}
+
+export async function nodeFallbackGlob(
+  pattern: string,
+  searchPath: string,
+): Promise<string> {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+
+  const results: string[] = [];
+  const isPathPattern = pattern.includes("/");
+
+  // Handle ** before * so double-star → .* and single-star → [^/]*
+  let regexPattern = pattern
+    .replace(/\./g, "\\.")
+    .replace(/\*\*/g, "\x00") // placeholder for **
+    .replace(/\*/g, "[^/]*")
+    .replace(/\x00/g, ".*"); // restore ** as .*
+
+  let regex: RegExp;
+  try {
+    regex = isPathPattern
+      ? new RegExp(`${regexPattern}$`)
+      : new RegExp(`^${regexPattern}$`);
+  } catch {
+    return "No files found";
+  }
+
+  async function walk(dir: string): Promise<void> {
+    if (results.length >= 50) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading directory", { dir, code: err?.code, message: err?.message });
+      }
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 50) return;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!FALLBACK_SKIP_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const matchTarget = isPathPattern
+          ? fullPath.replace(/\\/g, "/")
+          : entry.name;
+        if (regex.test(matchTarget)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  }
+
+  await walk(searchPath);
+  return results.join("\n") || "No files found";
+}