main.js · part 232

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js, part 232. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

The number of results to return. Must be between 1 and ${r}.

The number of results to return. Defaults to ${r}. Do not specify a value larger than ${r}.

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

`SemanticSearch`: semantic search that finds code by meaning, not exact text

Find snippets of code from the codebase most relevant to the search query.
This is a semantic search tool, so the query should ask for something semantically matching what is needed.
Ask a complete question about what you want to understand. Ask as if talking to a colleague: 'How does X work?', 'What happens when Y?', 'Where is Z handled?
If it makes sense to only search in particular directories, please specify them in the target_directories field (single directory only, no glob patterns).

`${t}`: semantic search that finds code by meaning, not exact text

### When to Use This Tool

Use `${t}` when you need to:
- Explore unfamiliar codebases
- Ask "how / where / what" questions to understand behavior
- Find code by meaning rather than exact text

### When NOT to Use

Skip `${t}` for:
1. Exact text matches (use `${r}`)
2. Reading known files (use `${n}`)
3. Simple symbol lookups (use `${r}`)
4. Find file by name (use `${ML(e,"GLOB")}`)

### Examples

<example>
  Query: "Where is interface MyInterface implemented in the frontend?"
<reasoning>
  Good: Complete question asking about implementation location with specific context (frontend).
</reasoning>
</example>

<example>
  Query: "Where do we encrypt user passwords before saving?"
<reasoning>
  Good: Clear question about a specific process with context about when it happens.
</reasoning>
</example>

<example>
  Query: "MyInterface frontend"
<reasoning>
  BAD: Too vague; use a specific question instead. This would be better as "Where is MyInterface used in the frontend?"
</reasoning>
</example>

<example>
  Query: "AuthService"
<reasoning>
  BAD: Single word searches should use `${r}` for exact text matching instead.
</reasoning>
</example>

<example>
  Query: "What is AuthService? How does AuthService work?"
<reasoning>
  BAD: Combines two separate queries. A single semantic search is not good at looking for multiple things in parallel. Split into separate parallel searches: like "What is AuthService?" and "How does AuthService work?"
</reasoning>
</example>

### Target Directories

- Provide ONE directory or file path; [] searches the whole repo. No globs or wildcards.
  Good:
  - ["backend/api/"]   - focus directory
  - ["src/components/Button.tsx"] - single file
  - [] - search everywhere when unsure
  BAD:
  - ["frontend/", "backend/"] - multiple paths
  - ["src/**/utils/**"] - globs
  - ["*.ts"] or ["**/*"] - wildcard paths

### Search Strategy

1. Start with exploratory queries - semantic search is powerful and often finds relevant context in one go. Begin broad with [] if you're not sure where relevant code is.
2. Review results; if a directory or file stands out, rerun with that as the target.
3. Break large questions into smaller ones (e.g. auth roles vs session storage).
4. For big files (>1K lines) run `${t}`, or `${r}` if you know the exact symbols you're looking for, scoped to that file instead of reading the entire file.

<example>
  Step 1: { "query": "How does user authentication work?", "target_directories": [], "explanation": "Find auth flow" }
  Step 2: Suppose results point to backend/auth/ → rerun:
          { "query": "Where are user roles checked?", "target_directories": ["backend/auth/"], "explanation": "Find role logic" }
<reasoning>
  Good strategy: Start broad to understand overall system, then narrow down to specific areas based on initial results.
</reasoning>
</example>

<example>
  Query: "How are websocket connections handled?"
  Target: ["backend/services/realtime.ts"]
<reasoning>
  Good: We know the answer is in this specific file, but the file is too large to read entirely, so we use semantic search to find the relevant parts.
</reasoning>
</example>

### Usage
- When full chunk contents are provided, avoid re-reading the exact same chunk contents using the ${n} tool.
- Sometimes, just the chunk signatures and not the full chunks will be shown. Chunk signatures are usually Class or Function signatures that chunks are contained in. Use the ${n} or ${r} tools to explore these chunks or files if you think they might be relevant.
- When reading chunks that weren't provided as full chunks (e.g. only as line ranges or signatures), you'll sometimes want to expand the chunk ranges to include the start of the file to see imports, expand the range to include lines from the signature, or expand the range to read multiple chunks from a file at once.

Unhandled version: ${e}

Unhandled version: ${e}

No codebase index found. Use other search tools.

Index invalid. Use other search tools.

Codebase search is unavailable for this conversation because the codebase index could not be found. Do not retry ${e}. Use ${t?.GREP?.name??"Grep"}, ${t?.GLOB?.name??"Glob"}, and ${t?.READ?.name??"Read"} instead.

The semantic search results are empty. Consider using a different search query or using grep search instead to find relevant results.

Error: ${t.value.errorMessage}

Unknown error

tmux -f /exec-daemon/tmux.portal.conf

On this self-hosted machine, invoke tmux without `-f`. If `tmux` is not installed (`command -v tmux` prints nothing), run long-lived commands in the background with this tool instead.

On the VM, invoke tmux with `-f /exec-daemon/tmux.portal.conf`. If that config path is unavailable, fall back to the same command without `-f`.

SESSION_NAME="${r}"; ${n} has-session -t "=$SESSION_NAME" 2>/dev/null || ${n} new-session -d -s "$SESSION_NAME" -c "$PWD" -- "${SHELL:-zsh}" -l

tmux is the required mechanism for shell work that may outlive a single command. If you need an interactive shell, any background command (such as starting dev servers), a long-running process, follow-up input, later inspection, or a shared session that you or the user may reconnect to later, you MUST use tmux. Do NOT launch those workflows as one-shot background processes. If you are planning to set block_until_ms to 0, you should ALWAYS back this session with tmux.

There is one canonical shared tmux session for most recurring shell work — `

`. Start or reuse that session before ordinary setup work, then use it for every install, build, migration, version check, and verification command. Only create a separate descriptively-named session (short kebab-case, e.g. `vite-dev-server`, `backend-tests`, `postgres`) for long-running side processes that must keep running after a single command finishes. Do NOT invent a new per-task session name for ordinary shell work — route it through `

Use a descriptive tmux session name for the task or command instead of a single global shared name. Prefer short kebab-case names such as `vite-dev-server`, `backend-tests`, or `db-migration`.

Start or reuse the appropriate session by running

Before creating a new session, list existing sessions with 

`${r} ls`

 and reuse an existing one when appropriate.

To inspect or continue work in an existing session, attach with

`${r} attach-session -t "$SESSION_NAME"`

To send input to a session without attaching, run

`${r} send-keys -t "$SESSION_NAME:0.0" 'your command here' C-m`

Optional list of permissions to request if the command needs them (full_network).

Optional list of permissions to request if the command needs them (full_network, all).

Optional list of permissions to request if the command needs them (full_network, all).

The sandbox includes network access for common package managers and version control providers (e.g. npm, pypi, crates.io, Maven Central, GitHub, etc.). Standard operations like package installs and fetching dependencies will work without requesting additional permissions.

Additionally, the

 sandbox includes network access for the following domains: 

. You do not need to request 'full_network' permissions for these domains.

For broader network access beyond the allowed domains, you may still need to request 'full_network' permissions.

Your commands will run in a readonly sandbox. The sandbox allows reads to the filesystem but does not allow any writes.

 Network access is disallowed by default but can be requested with the full_network permission.

The required_permissions argument is used to request additional permissions:

full_network: Grants unrestricted network access beyond the allowed domains.

full_network: Grants unrestricted network access.

By default, your commands will run in a sandbox. The sandbox allows most writes to the workspace and reads to the rest of the filesystem. Some other syscalls are also disallowed like access to USB devices. Syscalls that attempt forbidden operations will fail and not all programs will surface these errors in a useful way.

Files that are ignored by .cursorignore are not accessible to the command. If you need to access a file that is ignored, you will need to request "all" permissions to disable sandboxing.

The required_permissions argument is used to request additional permissions. If you know you will need a permission, request it. Requesting permissions will slow down the command execution as it will ask the user for approval. Do not hesitate to request permissions if you are certain you need them. For commands you know will need unrestricted network access, request the full_network permission rather than waiting for the command to fail and asking for it later.

The following permissions are supported:

full_network: Grants unrestricted network access to run a server or contact the internet. Needed for package installs, API calls, hosting servers and fetching dependencies.

full_network: Grants unrestricted network access. This is useful for any commands that need to contact the outside internet, outside of the allowed domains.

all: Disables the sandbox entirely. If all is requested the command will run outside of the sandbox.

If you think a command failed due to sandbox restrictions, run the command again with the required_permissions argument to request what you need.

Execute shell commands in the workspace.

The shell is stateful - cwd & env vars persist for subsequent calls.

Make efficient use of shell calls and minimize wasted tokens.

Batch related shell work together or run independent checks in parallel when safe. Make liberal use of `&&`, `;`, pipes, greps, and other efficient shell use.

Use targeted, output-limited terminal commands such as `rg`, `head`, `tail`, and `sed -n` when relevant to limit output.