main.js · part 238

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

File contents and all parts · All files

Before executing the command, please follow these steps:

Check for Running Processes:

Before starting dev servers or long-running processes that should not be duplicated, search the terminals folder to check if they are already running in existing terminals.

You can use this information to determine which terminal, if any, matches the command you want to run, contains the output from the command you want to inspect, or has changed since you last read them.

Since these are text files, you can read any terminal's contents simply by reading the file

, search using 

Directory Verification:

If the command will create new directories or files, first run ls to verify the parent directory exists and is the correct location

For example, before running "mkdir foo/bar", first run 'ls' to check that "foo" exists and is the intended parent directory

Command Execution:

Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")

Examples of proper quoting:

cd "/Users/name/My Documents" (correct)

cd /Users/name/My Documents (incorrect - will fail)

python "/path/with spaces/script.py" (correct)

python /path/with spaces/script.py (incorrect - will fail)

Treat the command argument as executable shell text: backticks and `$()` perform command substitution. Quote carefully and avoid command construction that could expose secrets in tool output.

After ensuring proper quoting, execute the command.

Capture the output of the command.

IMPORTANT: Do not run any long-lived processes such as watch commands, dev commands that run forever (like npm run dev for react apps), or anything that is a background process. This makes the conversation hang forever for the user. It is essential to avoid this, and refuse if the user asks you to do so.

Usage notes:

The command argument is required.

The shell starts in the workspace root and is stateful across sequential calls. Current working directory and environment variables persist between calls. Use the `working_directory` parameter to run commands in different directories. Example: to run `npm install` in the `frontend` folder, set `working_directory: "frontend"` rather than using `cd frontend && npm install`.

You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 30000ms (30 seconds).

It is very helpful if you write a clear, concise description of what this command does in 5-10 words.

Avoid using search commands like `find` and `grep`.

Instead prefer 

 to search.

Avoid read tools like `cat`, `head`, and `tail`, and prefer 

 to read files.

 Avoid editing files with tools like `sed` and `awk`, use 

Don't pipe a command's output through `head`, `tail`, or `sed -n` (or similar) just to limit its length — large output is automatically written to a terminal file that you can read in full, so truncating only risks discarding information you need (especially for long-running commands).

If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all users have pre-installed.

You do not need to use '&' at the end of commands when setting `is_background: true`.

When issuing multiple commands:

If the commands are independent and can run in parallel, make multiple 

tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two 

 tool calls in parallel.

If the commands depend on each other and must run sequentially, use a single

 call with '&&' to chain them together (e.g., `git add . && git commit -m "message" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp,

 for git operations,

or git add before git commit), run these operations sequentially instead.

Use ';' only when you need to run commands sequentially but don't care if earlier commands fail

DO NOT use newlines to separate commands (newlines are ok in quoted strings)

When adding new dependencies, prefer using the package manager (e.g. npm, pip) to add the latest version. Do not make up dependency versions.

Managing long-running commands

Commands that don't complete within `block_until_ms` (default

 ${hL(c)}

) are moved to background. The command keeps running and output streams to a terminal file. Set `block_until_ms: 0` to immediately background (use for dev servers, watchers, or any long-running process).

You do not need to use '&' at the end of commands.

Make sure to set `block_until_ms` to higher than the command's expected runtime. Add some buffer since block_until_ms includes shell startup time; increase buffer next time based on `elapsed_ms` if you chose too low. E.g. if you sleep for 40s, recommended `block_until_ms` is 45s.

Monitoring backgrounded commands:

When command moves to background, check status immediately by reading the terminal file.

Header has `pid` and `running_for_ms` (updated every 5000ms)

When finished, footer with `exit_code` and `elapsed_ms` appears.

Poll repeatedly to monitor by sleeping between checks. If the file gets large, read from the end of the file to capture the latest content.

Pick your sleep intervals using best guess/judgment based on any knowledge you have about the command and its expected runtime, and any output from monitoring the command. When no new output, exponential backoff is a good strategy (e.g. sleep 2000ms, 4000ms, 8000ms, 16000ms...), using educated guess for min and max wait.

If it's longer than expected and the command seems like it is hung, kill the process if safe to do so using the pid that appears in the header. If possible, try to fix the hang and proceed.

Don't stop polling until: (a) `exit_code` footer appears (terminating command), (b) the command reaches a healthy steady state (only for non-terminating command, e.g. dev server/watcher), or (c) command is hung - follow guidance above.

You'll be notified when the backgrounded command completes.