bash-linux
sickn33/agentic-awesome-skills
Essential Bash/Linux terminal patterns, commands, and scripting for macOS and Linux systems.
What is bash-linux?
Reference guide for Bash shell operations on Linux/macOS, covering command chaining, file operations, process management, text processing, and scripting patterns. Use when working directly with terminal tasks on Unix-like systems.
- Command chaining with operators (&&, ||, |, ;) for sequential and conditional execution
- File operations including listing, finding, searching, and monitoring logs
- Process management: listing, killing, finding by port, and background job control
- Text processing with grep, sed, awk, cut, sort, and uniq for data extraction and transformation
- Environment variable management and PATH configuration
- Network operations with curl and netcat for downloads and API requests
How to install bash-linux
npx skills add https://github.com/sickn33/agentic-awesome-skills --skill bash-linuxHow to use bash-linux
- 1.Reference the appropriate section (File Operations, Process Management, Text Processing, etc.) for your task
- 2.Use the provided command syntax and examples as templates for your specific use case
- 3.For scripts, start with the provided template and add your logic in the main() function
- 4.Apply error handling patterns (set -e, set -u, set -o pipefail) at the top of scripts for safety
- 5.Test commands interactively before adding them to automated scripts
Use cases
- Automating deployment or build workflows on Linux/macOS servers
- Searching and processing log files or large datasets with grep and text tools
- Managing running processes and debugging port conflicts
- Writing robust shell scripts with proper error handling and cleanup
- Chaining multiple commands in CI/CD pipelines or local development workflows
- DevOps engineers and system administrators
- Backend developers working on Linux/macOS systems
- CI/CD pipeline builders and automation engineers
- Anyone writing shell scripts or working in terminal environments
bash-linux FAQ
Use && when the next command depends on the previous succeeding (e.g., npm install && npm run dev). Use || to run a fallback if the previous fails (e.g., npm test || echo 'Tests failed'). Use ; to run commands sequentially regardless of success.
Add set -e at the top of your script, or use set -euo pipefail for stricter error handling that also exits on undefined variables and pipe failures.
Piping (|) sends the output of one command as input to another. Command substitution $() captures the output of a command and uses it as a value in another command.
Use lsof -i :PORT to find the process ID, then kill -9 PID. Or combine them: kill -9 $(lsof -t -i :3000) to kill the process on port 3000.
No, this skill is for Bash on Linux/macOS. For Windows, use PowerShell patterns or Windows Command Prompt. Windows Subsystem for Linux (WSL) can run Bash.
Full instructions (SKILL.md)
Source of truth, from sickn33/agentic-awesome-skills.
name: bash-linux description: "Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems." risk: critical source: community date_added: "2026-02-27"
Bash Linux Patterns
Essential patterns for Bash on Linux/macOS.
1. Operator Syntax
Chaining Commands
| Operator | Meaning | Example |
|---|---|---|
; | Run sequentially | cmd1; cmd2 |
&& | Run if previous succeeded | npm install && npm run dev |
|| | Run if previous failed | npm test || echo "Tests failed" |
| | Pipe output | ls | grep ".js" |
2. File Operations
Essential Commands
| Task | Command |
|---|---|
| List all | ls -la |
| Find files | find . -name "*.js" -type f |
| File content | cat file.txt |
| First N lines | head -n 20 file.txt |
| Last N lines | tail -n 20 file.txt |
| Follow log | tail -f log.txt |
| Search in files | grep -r "pattern" --include="*.js" |
| File size | du -sh * |
| Disk usage | df -h |
3. Process Management
| Task | Command |
|---|---|
| List processes | ps aux |
| Find by name | ps aux | grep node |
| Kill by PID | kill -9 <PID> |
| Find port user | lsof -i :3000 |
| Kill port | kill -9 $(lsof -t -i :3000) |
| Background | npm run dev & |
| Jobs | jobs -l |
| Bring to front | fg %1 |
4. Text Processing
Core Tools
| Tool | Purpose | Example |
|---|---|---|
grep | Search | grep -rn "TODO" src/ |
sed | Replace | sed -i 's/old/new/g' file.txt |
awk | Extract columns | awk '{print $1}' file.txt |
cut | Cut fields | cut -d',' -f1 data.csv |
sort | Sort lines | sort -u file.txt |
uniq | Unique lines | sort file.txt | uniq -c |
wc | Count | wc -l file.txt |
5. Environment Variables
| Task | Command |
|---|---|
| View all | env or printenv |
| View one | echo $PATH |
| Set temporary | export VAR="value" |
| Set in script | VAR="value" command |
| Add to PATH | export PATH="$PATH:/new/path" |
6. Network
| Task | Command |
|---|---|
| Download | curl -O https://example.com/file |
| API request | curl -X GET https://api.example.com |
| POST JSON | curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL |
| Check port | nc -zv localhost 3000 |
| Network info | ifconfig or ip addr |
7. Script Template
#!/bin/bash
set -euo pipefail # Exit on error, undefined var, pipe fail
# Colors (optional)
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'
# Script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# Functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }
# Main
main() {
log_info "Starting..."
# Your logic here
log_info "Done!"
}
main "$@"
8. Common Patterns
Check if command exists
if command -v node &> /dev/null; then
echo "Node is installed"
fi
Default variable value
NAME=${1:-"default_value"}
Read file line by line
while IFS= read -r line; do
echo "$line"
done < file.txt
Loop over files
for file in *.js; do
echo "Processing $file"
done
9. Differences from PowerShell
| Task | PowerShell | Bash |
|---|---|---|
| List files | Get-ChildItem | ls -la |
| Find files | Get-ChildItem -Recurse | find . -type f |
| Environment | $env:VAR | $VAR |
| String concat | "$a$b" | "$a$b" (same) |
| Null check | if ($x) | if [ -n "$x" ] |
| Pipeline | Object-based | Text-based |
10. Error Handling
Set options
set -e # Exit on error
set -u # Exit on undefined variable
set -o pipefail # Exit on pipe failure
set -x # Debug: print commands
Trap for cleanup
cleanup() {
echo "Cleaning up..."
rm -f /tmp/tempfile
}
trap cleanup EXIT
Remember: Bash is text-based. Use
&&for success chains,set -efor safety, and quote your variables!
When to Use
This skill is applicable to execute the workflow or actions described in the overview.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Related skills
More from sickn33/agentic-awesome-skills and the wider catalog.

bash-scripting
Workflow for creating production-ready bash scripts with defensive patterns, error handling, and testing.

blockchain-developer
Build production-ready Web3 applications, smart contracts, and decentralized systems with expert guidance.

brainstorming
Transform vague ideas into validated designs through structured dialogue before implementation.

browser-automation
Build reliable browser automation tests using semantic locators, isolated contexts, and explicit outcome verification.

browser-extension-builder
Build Chrome, Firefox, and cross-browser extensions with Manifest V3, content scripts, and store publishing.

bullmq-specialist
Redis-backed job queues and reliable async execution for Node.js/TypeScript applications.