main.js · part 235

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

File contents and all parts · All files

- You'll be notified when the backgrounded command completes. Only poll with `${a}` 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 `${a}` later if you end up blocked on the result.

- Use `${a}` to monitor the background command.

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

Executes a given command in a shell session with optional foreground timeout.
Before executing the command, please follow these steps:
1. 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 the grep tool, etc.
2. 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)
   - After ensuring proper quoting, execute the command.
   - Capture the output of the command.
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.
- 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 Grep, Glob to search. Avoid read tools like `cat`, `head`, and `tail`, and prefer Read to read files. Avoid editing files with tools like `sed` and `awk`, use Edit instead.
- If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all users have pre-installed.
- When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings).
- Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.

${`Managing long-running commands:\n- Commands that don't complete within \`block_until_ms\`${d?"":` (default ${function(e){const t=e/1e3;if(Number.isInteger(t))return`${t}s`;return`${e}ms`}(p??3e4)})`} 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).\n- You do not need to use '&' at the end of commands.\n- 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.\n${t}${e}`}

Managing long-running commands:
- Commands that don't complete within `block_until_ms`${d?"":` (default ${function(e){const t=e/1e3;if(Number.isInteger(t))return`${t}s`;return`${e}ms`}(p??3e4)})`} 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.
${t}${e}

 (default ${function(e){const t=e/1e3;if(Number.isInteger(t))return`${t}s`;return`${e}ms`}(p??3e4)})

${iye}
- ${f}

The terminal command to execute

Whether the command should be run in the background

One sentence explanation as to why this command needs to be run and how it contributes to the goal.

The command to execute

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

Timeout in milliseconds (defaults to 30000ms/30s)

Clear, concise description of what this command does in 5-10 words. Examples:
Input: ls
Output: Lists files in current directory

Input: git status
Output: Shows working tree status

Input: npm install
Output: Installs package dependencies

Input: mkdir foo
Output: Creates directory 'foo'

Whether the command should be run in the background

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"})

${e}ms (${r} minute${1===r?"":"s"})

The command to execute

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

Clear, concise description of what this command does in 5-10 words. Examples:
Input: ls
Output: Lists files in current directory

Input: git status
Output: Shows working tree status

Input: npm install
Output: Installs package dependencies

Input: mkdir foo
Output: Creates directory 'foo'

How long to block and wait for the command to complete before moving it to background (in milliseconds). Set to 0 to immediately run the command in the background. The timer includes the shell startup time.

How long to block and wait for the command to complete before moving it to background (in milliseconds). Defaults to 30000ms (30 seconds). Set to 0 to immediately run the command in the background. 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 previous elapsed times if you chose too low. E.g. if you sleep for 40s, recommended `block_until_ms` is 45s. Do not specify a 'timeout' parameter; no such param exists.

 --trailer "${MQ}"

Made with [Cursor](https://cursor.com)

co-authored-by: ${RQ.toLowerCase()}

Made-with: Cursor

Made with [Cursor]

Made with [Cursor]

Auto-review shell approval store is not configured

Object expected.

Symbol.asyncDispose is not defined.

Symbol.dispose is not defined.

Object not disposable.

An error was suppressed during disposal.

Count of 'command not found: dump_zsh_state' errors in shell output

Count of foreground shell executions whose exec stream closed without an exit event (likely exec backend unavailable/desynced)

Git commit trailer modifier applications

PR generated-by footer modifier applications

Rejected: ${r}

Permission denied: ${r}

Permission denied: ${r}

Terminal unavailable: this machine cannot enforce the '${r}' sandbox policy this command requires, because no working sandbox backend is available (${n}). This is not a permission denial. Commands requiring this policy cannot run here unless sandbox support is set up on this machine.

Output collected before the stream closed

 (truncated to 20000 characters)

${Iz}

${t}

Command blocked by Auto-review preflight

notify_on_output must be an object

notify_on_output.pattern must be a string

notify_on_output.pattern is required

notify_on_output.pattern must be 500 characters or fewer

Invalid notify_on_output pattern: ${e instanceof Error?e.message:String(e)}

notify_on_output.reason must be a string

notify_on_output.reason is required

notify_on_output.reason must be 200 characters or fewer

notify_on_output.debounce_ms must be a number of milliseconds

notify_on_output.debounce_ms must be finite

notify_on_output.debounce_ms must be greater than 0

Set to true when immediately retrying the exact same command after Auto-review blocks it and you decide the user should approve it through the native approval card.

Provide the exact block reason returned by Auto-review in the prior rejection. Required when request_smart_mode_approval is true so the approval card shows the original classifier reason without re-running the classifier.