Untitled

Agentforce Vibes Safe Commands

Safe commands enable Agentforce Vibes to run approved terminal commands automatically, without interrupting your workflow for manual approval. You control which commands are safe through a configurable allowlist. Before adding commands to your safe list, review them for security implications to ensure that they don't pose risks to your development environment.

Configure Your Safe Commands

1. In the Agentforce chat panel, click Auto-approve to open the Auto-approve settings.
2. Click Safe Commands Allowlist to open your a4d_safe_commands file.
3. Add commands to the file, one per line.
4. Use # at the start of a line to add comments. Agentforce ignores commented lines.
5. Save the file.

Match Commands Your Way

Agentforce Vibes gives you two approaches to match commands in your safe list, each suited to different levels of control and flexibility.

Exact Matching

With exact matching, you specify commands precisely as they appear in the terminal. Agentforce auto-approves only commands that match each character exactly. This is always a safer option.

Examples:

git status
npm run lint
sf project retrieve start
sf org display

When you add git status to your safe commands list, Agentforce auto-approves only git status. Variations like git status --short or git log still require your manual approval, giving you fine-grained control.

Flexible Matching (Advanced)

When you frequently use a command with different arguments, flexible matching saves time. Add ... after the base command to approve it regardless of the arguments that follow.

Examples:

git checkout ...
sf project deploy start ...
npm run ...
echo ...

With git checkout ... in your safe commands list, Agentforce auto-approves all of these commands:

• git checkout main
• git checkout -b feature-branch
• git checkout v1.2.3

Flexible patterns respect word boundaries. The pattern git checkout ... matches git checkout main but not git checkoutfoo, ensuring pattern safety.

Chain Commands Safely

Agentforce Vibes understands compound commands, which multiple commands connected by separators in a single-line. When you run a compound command, Agentforce validates each individual command against your safe list.

Supported separators:

• ; (semicolon) - Sequential execution
• & (background) - Run in background
• && (AND) - Run second command only if first succeeds
• || (OR) - Run second command only if first fails
• Newlines (\n) - Multiple lines in the same execution

Examples:

npm run build && npm test
sf project retrieve start || echo "Retrieve failed"
git add . && git status
echo "Starting build"; npm run build; echo "Build complete"
npm test & npm run lint

Agentforce auto-approves a compound command only when every command in the chain exists in your safe list. If you run npm run build && npm test, you must list both npm run buildand npm test as safe commands— either individually or as the full compound command.

Security Note: Pipelines (|) and redirections (>, <, >>) always require manual approval. These operators can modify command behavior and potentially enable data exfiltration, so Agentforce treats them as high-risk patterns regardless of your safe list configuration.

Work with Quotes Safely

Agentforce Vibes interprets shell quoting rules intelligently, distinguishing between operators that run and text that's simply displayed, allowing you to use legitimate commands with special characters while maintaining security.

Separators as Literal Text

When separators and special characters appear inside quotes, Agentforce treats them as literal text rather than operational commands.

These are safe (separators become text):

echo "hello; world"
git commit -m "fix: A & B"
echo "data | formatted"
npm test --grep "test: integration"

When you have echo ... in your safe commands list, Agentforce auto-approves all of the commands because the separators are safely contained within quotes. Agentforce reads them as just text instead of executable operators.

Understanding Quote Types

Different quote types offer different levels of security. Choose the right quote type based on what you're trying to accomplish.

Single Quotes (Safest Option)

Single quotes prevent all shell expansion and substitution, treating everything inside as literal text.

echo '$(whoami)'          # Safe - command substitution won't execute
echo '${HOME}'            # Safe - variable expansion won't happen

Double Quotes (Use carefully)

Double quotes allow variable expansion and command substitution, which creates security risks.

echo "$(whoami)"          # Rejected - command substitution executes
echo "${HOME}"            # Rejected - variable expansion happens
echo "hello world"        # Safe - contains only literal text

Agentforce always requires approval for double-quoted strings containing command substitution $() or variable expansion ${...}. These patterns execute code dynamically, making them inherently risky even in a safe list.

Disallowed Command Patterns

Agentforce Vibes prioritizes your security by automatically blocking high-risk command patterns, regardless of your safe list configuration. Understanding these restrictions helps you work safely while maintaining productivity.

Safe When Quoted

These patterns are safe when they appear inside quotes because they're treated as literal text rather than executable operators:

• Separators: echo "hello; world" — the semicolon is just text in your output
• Operators: git commit -m "A & B" — the ampersand is part of your commit message
• Pipes: echo "data | formatted" — the pipe symbol appears in your text output

Build Your Safe Commands File

Here's a practical example showing how to structure your a4d_safe_commands file. This example demonstrates exact matching, flexible patterns, multi-command chains, and safe quote usage.

# Safe Commands List
# --
# Commands listed here run automatically *without asking for approval* when "Run Safe Commands" is enabled in Auto-approve Settings.
# Lines beginning with "#" are comments and ignored.

# Git commands - exact matching
git status
git diff
git log
git branch

# Salesforce CLI commands - exact matching
sf project retrieve start
sf org display
sf org list

# Build and test commands
npm run lint
npm test
npm run build

# Multi-command examples (all separators supported)
npm run build && npm test
git add . && git status
sf org display || echo "No default org set"
echo "Starting..."; npm run build; echo "Done"

# Commands with separators in commit messages (quotes make them safe)
git commit -m "fix: issue A & B"
echo "Running tests; please wait"

# Advanced: Flexible matching for commands with arguments
# (Add ... to match the command with any arguments)
git checkout ...
sf project deploy start ...
npm run ...
echo ...

Work Safely with Safe Commands

Follow these practices to maintain security while maximizing productivity with safe commands.

Start with exact matching. Exact matching gives you precise control over auto-approved commands. Add flexible patterns only when you've established trust with specific command families.

Test in development first. Before adding commands to your production workflow, verify them in a development environment, helping you catch unintended side effects.

Review regularly. Audit your safe commands list periodically. Remove commands you no longer use to minimize your security surface area.

Organize with comments. Use # comments to group commands by category, project, or purpose. This makes your safe list easier to maintain as it grows.

Choose quotes wisely. Use single quotes when you need to prevent all shell expansion. Use double quotes only for literal text without variable expansion or command substitution.

Understand flexible patterns. The ... pattern is powerful but permissive. When you add git checkout ..., you're trusting all possible arguments. Use this pattern only for commands where you understand the full range of potential behaviors.