# Send openclaw-plus to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Then review README.md for any prerequisites, environment setup, or post-install checks. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Then review README.md for any prerequisites, environment setup, or post-install checks. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "openclaw-plus",
    "name": "openclaw-plus",
    "source": "tencent",
    "type": "skill",
    "category": "开发工具",
    "sourceUrl": "https://clawhub.ai/Shindo957-Official/openclaw-plus",
    "canonicalUrl": "https://clawhub.ai/Shindo957-Official/openclaw-plus",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/openclaw-plus",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=openclaw-plus",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "CHANGELOG.md",
      "LICENSE.txt",
      "manifest.json",
      "PUBLISHING.md",
      "QUICKSTART.md",
      "README.md"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "openclaw-plus",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-05-12T11:28:59.398Z",
      "expiresAt": "2026-05-19T11:28:59.398Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=openclaw-plus",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=openclaw-plus",
        "contentDisposition": "attachment; filename=\"openclaw-plus-1.0.0.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "openclaw-plus"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/openclaw-plus"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/openclaw-plus",
    "downloadUrl": "https://openagent3.xyz/downloads/openclaw-plus",
    "agentUrl": "https://openagent3.xyz/skills/openclaw-plus/agent",
    "manifestUrl": "https://openagent3.xyz/skills/openclaw-plus/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/openclaw-plus/agent.md"
  }
}
```
## Documentation

### OpenClaw+ 🚀

A modular super-skill that combines essential developer tools and web capabilities into a unified, powerful workflow.

### Overview

OpenClaw+ integrates seven core capabilities into one streamlined skill:

Developer Skills:

run_python - Execute Python code with proper environment management
git_status - Check repository status and track changes
git_commit - Commit changes with meaningful messages
install_package - Install Python packages with dependency handling

Web Skills:

fetch_url - Retrieve web content with robust error handling
call_api - Make API requests with authentication and response parsing

This modular design allows you to chain operations efficiently - install packages, run code, fetch data, commit results - all in one cohesive workflow.

### When to Use OpenClaw+

Use this skill when the user's request involves:

Running Python scripts or code snippets
Installing Python packages (pip, conda, system packages)
Checking git repository status
Committing code changes
Fetching content from URLs
Making API calls (REST, GraphQL, etc.)
Combining any of the above in a workflow

Common patterns:

"Install pandas and run this analysis"
"Fetch data from this API and save it"
"Check git status and commit my changes"
"Run this script and call this endpoint"
"Install these packages, run the code, then commit"

### 1. Python Execution (run_python)

Execute Python code with proper environment management and output capture.

Key features:

Captures stdout, stderr, and return values
Handles exceptions gracefully
Supports multi-line scripts
Access to installed packages
Environment variable support

Usage patterns:

# Simple execution
result = run_python("print('Hello, world!')")

# With installed packages
run_python("""
import pandas as pd
import numpy as np

data = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
print(data.describe())
""")

# File operations
run_python("""
with open('output.txt', 'w') as f:
    f.write('Results: ...')
""")

Best practices:

Always check for syntax errors before execution
Handle file paths carefully (use absolute paths when needed)
Capture exceptions and provide clear error messages
For large scripts, consider creating a .py file first

### 2. Package Installation (install_package)

Install Python packages with intelligent dependency resolution.

Key features:

Pip package installation
System package support (apt, brew, etc.)
Conda environment support
Dependency conflict detection
Version pinning

Usage patterns:

# Install single package
install_package("pandas")

# Install specific version
install_package("numpy==1.24.0")

# Install multiple packages
install_package("requests beautifulsoup4 lxml")

# Install from requirements.txt
install_package("-r requirements.txt")

# System packages (when needed)
install_package("libpq-dev", system=True)

Best practices:

Always use --break-system-packages flag for pip in this environment
Check if package is already installed before installing
Handle version conflicts explicitly
Provide clear feedback on installation success/failure

Implementation:

pip install <package> --break-system-packages

### 3. Git Status (git_status)

Check repository status and track changes.

Key features:

Shows modified, added, deleted files
Displays untracked files
Shows current branch
Indicates if ahead/behind remote
Supports custom git directories

Usage patterns:

# Check current directory
git_status()

# Check specific directory
git_status("/path/to/repo")

# Parse output for automation
status = git_status()
if "modified:" in status:
    print("Changes detected")

Best practices:

Always check status before committing
Parse output to detect specific changes
Handle cases where directory isn't a git repo
Provide context about what changed

Implementation:

git status
git diff --stat
git log -1 --oneline

### 4. Git Commit (git_commit)

Commit changes with meaningful messages following best practices.

Key features:

Conventional commit format support
Multi-line commit messages
Automatic staging option
Commit message validation
Amend support

Usage patterns:

# Simple commit
git_commit("Add new feature")

# Conventional commit
git_commit("feat: add user authentication")

# Multi-line with description
git_commit("""
feat: add data processing pipeline

- Implement CSV reader
- Add data validation
- Create output formatter
""")

# Stage and commit
git_commit("fix: resolve parsing error", stage_all=True)

Best practices:

Use conventional commit format: type(scope): description
Types: feat, fix, docs, style, refactor, test, chore
Keep first line under 50 characters
Add detailed description if needed
Reference issue numbers when applicable

Implementation:

git add <files>  # if stage_all
git commit -m "<message>"
git log -1 --oneline  # confirm commit

### 5. URL Fetching (fetch_url)

Retrieve content from URLs with robust error handling.

Key features:

HTTP/HTTPS support
Custom headers
Authentication support
Redirect following
Timeout handling
Response parsing (JSON, XML, HTML, text)

Usage patterns:

# Fetch HTML
html = fetch_url("https://example.com")

# Fetch JSON
data = fetch_url("https://api.example.com/data", 
                 parse_json=True)

# With authentication
content = fetch_url("https://api.example.com/protected",
                    headers={"Authorization": "Bearer TOKEN"})

# With custom timeout
content = fetch_url("https://slow-site.com", timeout=30)

# POST request
response = fetch_url("https://api.example.com/submit",
                     method="POST",
                     data={"key": "value"})

Best practices:

Always handle network errors gracefully
Set appropriate timeouts
Validate URLs before fetching
Parse response based on content type
Handle rate limiting
Respect robots.txt

Implementation:

import requests

response = requests.get(url, headers=headers, timeout=timeout)
response.raise_for_status()
return response.text  # or response.json()

### 6. API Calls (call_api)

Make API requests with authentication and response parsing.

Key features:

REST API support
GraphQL support
Authentication (Bearer, Basic, API Key)
Request/response logging
Error handling with retries
Response validation

Usage patterns:

# Simple GET request
data = call_api("https://api.example.com/users")

# With authentication
data = call_api("https://api.example.com/data",
                auth_token="your-token")

# POST with JSON body
result = call_api("https://api.example.com/create",
                  method="POST",
                  json_data={"name": "John", "age": 30})

# With custom headers
data = call_api("https://api.example.com/endpoint",
                headers={"X-Custom-Header": "value"})

# GraphQL query
result = call_api("https://api.example.com/graphql",
                  method="POST",
                  json_data={
                      "query": "{ users { id name } }"
                  })

Best practices:

Validate API keys/tokens before use
Handle rate limits with exponential backoff
Parse response format (JSON, XML, etc.)
Log requests for debugging
Handle pagination for large datasets
Validate response schemas
Use appropriate HTTP methods (GET, POST, PUT, DELETE, PATCH)

Implementation:

import requests

headers = {"Authorization": f"Bearer {token}"}
response = requests.request(
    method=method,
    url=url,
    headers=headers,
    json=json_data,
    timeout=30
)
response.raise_for_status()
return response.json()

### Workflow Patterns

OpenClaw+ shines when combining multiple capabilities:

### Pattern 1: Data Pipeline

# 1. Install dependencies
install_package("pandas requests")

# 2. Fetch data from API
data = call_api("https://api.example.com/dataset")

# 3. Process with Python
run_python("""
import pandas as pd
import json

with open('raw_data.json', 'r') as f:
    data = json.load(f)

df = pd.DataFrame(data)
df_cleaned = df.dropna()
df_cleaned.to_csv('cleaned_data.csv', index=False)
print(f'Processed {len(df_cleaned)} records')
""")

# 4. Commit results
git_commit("feat: add cleaned dataset")

### Pattern 2: Web Scraping & Analysis

# 1. Install scraping tools
install_package("beautifulsoup4 lxml requests")

# 2. Fetch webpage
html = fetch_url("https://example.com/data-page")

# 3. Parse and analyze
run_python("""
from bs4 import BeautifulSoup
import json

with open('page.html', 'r') as f:
    soup = BeautifulSoup(f, 'lxml')

data = []
for item in soup.find_all('div', class_='data-item'):
    data.append({
        'title': item.find('h2').text,
        'value': item.find('span', class_='value').text
    })

with open('scraped_data.json', 'w') as f:
    json.dump(data, f, indent=2)
""")

# 4. Check and commit
git_status()
git_commit("chore: update scraped data")

### Pattern 3: API Integration Testing

# 1. Install testing tools
install_package("pytest requests-mock")

# 2. Run tests
run_python("""
import requests
import json

# Test API endpoint
response = requests.get('https://api.example.com/health')
assert response.status_code == 200

# Test with authentication
headers = {'Authorization': 'Bearer test-token'}
response = requests.get('https://api.example.com/data', headers=headers)
print(f'Status: {response.status_code}')
print(f'Data: {response.json()}')
""")

# 3. Commit test results
git_commit("test: add API integration tests")

### Pattern 4: Automated Reporting

# 1. Fetch data from multiple sources
api_data = call_api("https://api.example.com/metrics")
web_data = fetch_url("https://example.com/reports/latest")

# 2. Process and generate report
install_package("matplotlib pandas")
run_python("""
import pandas as pd
import matplotlib.pyplot as plt
import json

with open('api_data.json', 'r') as f:
    data = json.load(f)

df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])

plt.figure(figsize=(10, 6))
plt.plot(df['date'], df['value'])
plt.title('Metrics Over Time')
plt.savefig('report.png')
print('Report generated')
""")

# 3. Commit report
git_commit("docs: add automated metrics report")

### Error Handling

Each capability includes robust error handling:

### Python Execution Errors

try:
    result = run_python(code)
except SyntaxError as e:
    print(f"Syntax error: {e}")
except RuntimeError as e:
    print(f"Runtime error: {e}")

### Package Installation Errors

# Handle already installed
if package_installed("pandas"):
    print("Package already installed")
else:
    install_package("pandas")

# Handle installation failure
try:
    install_package("nonexistent-package")
except Exception as e:
    print(f"Installation failed: {e}")

### Git Operation Errors

# Not a git repository
if not is_git_repo():
    print("Not a git repository")
    exit(1)

# Nothing to commit
status = git_status()
if "nothing to commit" in status:
    print("No changes to commit")

### Network Errors

# Handle timeouts
try:
    data = fetch_url(url, timeout=5)
except TimeoutError:
    print("Request timed out")

# Handle HTTP errors
try:
    response = call_api(url)
except requests.HTTPError as e:
    print(f"HTTP error: {e.response.status_code}")

### 1. Environment Management

Always use --break-system-packages for pip
Check if packages are installed before installing
Use virtual environments when appropriate
Document package versions

### 2. Git Operations

Check status before committing
Use meaningful commit messages
Follow conventional commit format
Stage only relevant files

### 3. Code Execution

Validate syntax before running
Handle exceptions gracefully
Capture and log output
Clean up temporary files

### 4. API/Web Requests

Set appropriate timeouts
Handle rate limiting
Validate responses
Log requests for debugging
Respect API usage limits

### 5. Workflow Composition

Chain operations logically
Handle errors at each step
Provide progress feedback
Document dependencies

### API Keys & Credentials

Never hardcode credentials
Use environment variables
Validate before use
Rotate regularly

### Code Execution

Validate input code
Sandbox when possible
Limit resource usage
Monitor execution

### Web Requests

Validate URLs
Use HTTPS when possible
Handle redirects carefully
Respect robots.txt

### Common Issues

Python execution fails:

Check syntax with python -m py_compile script.py
Verify packages are installed
Check file paths
Review error messages

Package installation fails:

Ensure pip is up to date
Check internet connectivity
Verify package name
Review dependencies

Git operations fail:

Verify it's a git repository
Check file permissions
Ensure clean working directory
Review git configuration

API/URL requests fail:

Verify URL is correct
Check authentication
Review rate limits
Check network connectivity

### Example 1: Complete Data Pipeline

# User request: "Fetch weather data, analyze it, and commit results"

# Step 1: Install dependencies
install_package("requests pandas matplotlib")

# Step 2: Fetch data
weather_data = call_api(
    "https://api.weather.com/data",
    auth_token="your-api-key"
)

# Step 3: Save and analyze
run_python("""
import pandas as pd
import matplotlib.pyplot as plt
import json

# Load data
with open('weather_data.json', 'r') as f:
    data = json.load(f)

# Create DataFrame
df = pd.DataFrame(data['forecast'])
df['date'] = pd.to_datetime(df['date'])

# Analyze
avg_temp = df['temperature'].mean()
max_temp = df['temperature'].max()
min_temp = df['temperature'].min()

# Generate plot
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['temperature'], marker='o')
plt.title('Temperature Forecast')
plt.xlabel('Date')
plt.ylabel('Temperature (°F)')
plt.grid(True)
plt.savefig('temperature_forecast.png')

# Save summary
summary = {
    'avg_temp': avg_temp,
    'max_temp': max_temp,
    'min_temp': min_temp,
    'records': len(df)
}

with open('weather_summary.json', 'w') as f:
    json.dump(summary, f, indent=2)

print(f'Analysis complete: {len(df)} records processed')
print(f'Average temperature: {avg_temp:.1f}°F')
""")

# Step 4: Commit results
git_status()
git_commit("""
feat: add weather data analysis

- Fetch 7-day forecast from API
- Generate temperature plot
- Create summary statistics
""")

### Example 2: Web Scraping & Storage

# User request: "Scrape product data and save to database"

# Step 1: Install tools
install_package("beautifulsoup4 lxml requests sqlite3")

# Step 2: Fetch webpage
html = fetch_url("https://example-shop.com/products")

# Step 3: Parse and store
run_python("""
from bs4 import BeautifulSoup
import sqlite3
import json

# Parse HTML
with open('products.html', 'r') as f:
    soup = BeautifulSoup(f, 'lxml')

products = []
for item in soup.find_all('div', class_='product'):
    product = {
        'name': item.find('h3').text.strip(),
        'price': float(item.find('span', class_='price').text.strip('$')),
        'rating': float(item.find('span', class_='rating').text),
        'url': item.find('a')['href']
    }
    products.append(product)

# Store in SQLite
conn = sqlite3.connect('products.db')
cursor = conn.cursor()

cursor.execute('''
    CREATE TABLE IF NOT EXISTS products (
        id INTEGER PRIMARY KEY,
        name TEXT,
        price REAL,
        rating REAL,
        url TEXT
    )
''')

for p in products:
    cursor.execute('''
        INSERT INTO products (name, price, rating, url)
        VALUES (?, ?, ?, ?)
    ''', (p['name'], p['price'], p['rating'], p['url']))

conn.commit()
conn.close()

print(f'Scraped and stored {len(products)} products')
""")

# Step 4: Commit
git_commit("chore: update product database")

### Example 3: API Testing Suite

# User request: "Test our API endpoints and generate report"

# Step 1: Install testing framework
install_package("pytest requests pytest-html")

# Step 2: Create test file and run
run_python("""
import requests
import json
from datetime import datetime

BASE_URL = "https://api.example.com"
results = []

# Test 1: Health check
try:
    response = requests.get(f"{BASE_URL}/health")
    results.append({
        'test': 'Health Check',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Health Check',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })

# Test 2: Authentication
try:
    headers = {'Authorization': 'Bearer test-token'}
    response = requests.get(f"{BASE_URL}/auth/validate", headers=headers)
    results.append({
        'test': 'Authentication',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Authentication',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })

# Test 3: Data retrieval
try:
    response = requests.get(f"{BASE_URL}/data/users")
    data = response.json()
    results.append({
        'test': 'Data Retrieval',
        'status': response.status_code,
        'passed': response.status_code == 200 and len(data) > 0,
        'records': len(data) if response.status_code == 200 else 0,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Data Retrieval',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })

# Generate report
report = {
    'timestamp': datetime.now().isoformat(),
    'total_tests': len(results),
    'passed': sum(1 for r in results if r.get('passed')),
    'failed': sum(1 for r in results if not r.get('passed')),
    'results': results
}

with open('api_test_report.json', 'w') as f:
    json.dump(report, f, indent=2)

print(f"Tests complete: {report['passed']}/{report['total_tests']} passed")
for r in results:
    status = '✓' if r.get('passed') else '✗'
    print(f"{status} {r['test']}")
""")

# Step 3: Check and commit
git_status()
git_commit("test: add API endpoint tests")

### Integration with Other Skills

OpenClaw+ works seamlessly with other skills:

### With docx skill:

# Generate data, then create report
call_api("https://api.example.com/stats")
run_python("process_stats.py")
# Then use docx skill to create formatted report

### With xlsx skill:

# Fetch data, process with Python, export to Excel
fetch_url("https://data-source.com/raw.csv")
run_python("clean_and_transform.py")
# Then use xlsx skill to create formatted spreadsheet

### With pptx skill:

# Generate charts and data visualizations
install_package("matplotlib seaborn")
run_python("generate_charts.py")
# Then use pptx skill to create presentation

### Python Execution

run_python(code_string)

### Package Management

install_package("package_name")
install_package("package==1.0.0")
install_package("-r requirements.txt")

### Git Operations

git_status()
git_commit("message")
git_commit("message", stage_all=True)

### Web Requests

fetch_url(url, timeout=30)
call_api(url, method="GET", auth_token="token")

### Conclusion

OpenClaw+ provides a unified, powerful toolkit for development and web automation workflows. By combining Python execution, package management, git operations, and web capabilities, it enables complex multi-step workflows with a single cohesive skill.

Key strengths:

✅ Modular design - use only what you need
✅ Error handling - robust failure recovery
✅ Workflow composition - chain operations easily
✅ Production-ready - follows best practices
✅ Well-documented - clear examples and patterns

Use OpenClaw+ whenever your task involves code execution, package management, version control, or web interactions - or any combination thereof!
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: Shindo957-Official
- Version: 1.0.0
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-05-12T11:28:59.398Z
- Expires at: 2026-05-19T11:28:59.398Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/openclaw-plus)
- [Send to Agent page](https://openagent3.xyz/skills/openclaw-plus/agent)
- [JSON manifest](https://openagent3.xyz/skills/openclaw-plus/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/openclaw-plus/agent.md)
- [Download page](https://openagent3.xyz/downloads/openclaw-plus)