main.js · part 140

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

File contents and all parts · All files

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

 ${iLe(l)}

) 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.

You can monitor commands by configuring `notify_on_output`. You will be notified at the end of your turn whenever stdout/stderr output matches the regex `pattern` (do not match all outputs). Output redirected only to a file will not trigger it. You will only receive notifications after ending your turn. Configure a 5 or less words `reason` which explains what you are watching for. The UI will prefix it as "Monitored `reason`". Configure `debounce_ms` to control how many milliseconds must elapse between notifications; the harness treats values less than 5000ms as 5000ms. Configure shell commands to emit stable sentinel lines and simple anchored regexes; pipe noisy output through jq/awk/scripts if needed. The system will terminate the watcher if the notifications are overly noisy, and you will be informed in this case.

Completion notifications are delivered separately from output-match notifications and do not require `notify_on_output` to be set.

Only poll with 

 later if you have been asked to work on something that requires the result of a previous shell command. Using the

 is very disruptive because it prevents you from being able to multitask.

You'll be notified when the backgrounded command completes. Only poll with

 when the command requires close monitoring — long-running jobs that can silently hang or degrade before completing (training runs, eval runs, deployments, long builds, datagen pipelines, DB migrations, large data transfers). For fire-and-forget commands (tests, installs, dev servers/watchers, short scripts), start them and keep working — you can always poll with 

later if you end up blocked on the result. If under your control, prefer commands that print periodic status updates so close monitoring is effective.

Use the 

 tool to monitor the background command. If under your control, prefer commands that print periodic status updates so you can monitor effectively.

Scheduling notifications

You can schedule notifications for yourself by starting a background shell that sleeps and echos a reminder message. This can be very useful for reminding yourself to check on another shell or task and verify it is making progress. Always think about how long you expect something to take before scheduling a notification.

tmux-backed shell sessions

Other common operations

View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments

The command to execute

The absolute path to the working directory to execute the command in (defaults to current directory)

${e}ms / ${Number.isInteger(t)?"":"~"}${r} second${1===r?"":"s"}

${e}ms / ${Number.isInteger(r)?"":"~"}${t} minute${1===t?"":"s"}

How long to block and wait for the command to complete before moving it to background (in milliseconds). Defaults to ${function(e){const t=e/1e3;if(Number.isInteger(t)&&t>0&&t<=120)return`${e}ms (${t} second${1===t?"":"s"})`;const r=e/6e4;return Number.isInteger(r)&&r>=1?`${e}ms (${r} minute${1===r?"":"s"})`:`${e}ms`}(e)}. Set to 0 to immediately run the command in the background. The timer includes the shell startup time.

${e}ms (${t} second${1===t?"":"s"})