How do I install the Managing Temp Scripts skill?

Run npx skillmds@latest add tomevault-io/managing-temp-scripts in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Managing Temp Scripts skill do?

Create and execute temporary scripts (Python, Node.js, shell) during workflow execution for API integrations, data processing, and custom tools. Use when user needs to interact with external APIs, process data with specific libraries, or create temporary executable code. Use when this capability is needed. It is listed under Integrations & APIs on SkillMD.

Is Managing Temp Scripts safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Managing Temp Scripts?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Managing Temp Scripts free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Managing Temp Scripts?

tomevault-io (@tomevault-io) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Managing Temp Scripts by tomevault-io

Name: Managing Temp Scripts
Author: tomevault-io

Managing Temporary Scripts

I help you create and execute temporary scripts during workflow execution. Perfect for API integrations, data processing with specialized libraries, and creating temporary tools that execute and return results.

When I Activate

I automatically activate when you:

Need to interact with external APIs (Reddit, Twitter, GitHub, etc.)
Want to use specific libraries not available in Claude Code
Need to process data with custom code
Ask "how do I call an API in a workflow?"
Mention "temporary script", "execute code", "API client"
Need credentials/API keys for external services

Key Concept

Temporary scripts are code files that:

Are created during workflow execution
Execute via Bash tool
Return results to workflow
Are automatically cleaned up after workflow completion

Supported Languages:

Python (with pip packages)
Node.js/JavaScript (with npm packages)
Shell/Bash scripts
Ruby, Go, or any executable language

Quick Example

# 1. Ask for API credentials
AskUserQuestion:"Reddit API key needed":api_key ->

# 2. Create Python script with embedded credentials
general-purpose:"Create Python script: reddit_client.py with {api_key}":script_path ->

# 3. Execute script and capture output
Bash:"python3 {script_path}":reddit_data ->

# 4. Process results in workflow
general-purpose:"Analyze {reddit_data} and create summary":analysis ->

# 5. Cleanup happens automatically

Script Lifecycle

See script-lifecycle.md for complete details.

Overview:

1. Creation
   ↓
   Write script to /tmp/workflow-scripts/

2. Preparation
   ↓
   Set permissions (chmod +x)
   Install dependencies if needed

3. Execution
   ↓
   Run via Bash tool
   Capture stdout/stderr

4. Data Return
   ↓
   Parse output (JSON, CSV, text)
   Pass to next workflow step

5. Cleanup
   ↓
   Remove script files
   Clean temp directories

Common Use Cases

1. API Integration

Reddit API Client:

# /tmp/workflow-scripts/reddit_client.py
import requests
import json
import sys

api_key = sys.argv[1]
subreddit = sys.argv[2]

headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get(
    f'https://oauth.reddit.com/r/{subreddit}/hot.json',
    headers=headers
)

print(json.dumps(response.json(), indent=2))

In workflow:

$script-creator:"Create reddit_client.py":script ->
Bash:"python3 {script} {api_key} programming":posts ->
general-purpose:"Parse {posts} and extract top 10 titles"

2. Data Processing

CSV Analysis:

# /tmp/workflow-scripts/analyze_data.py
import pandas as pd
import sys

df = pd.read_csv(sys.argv[1])
summary = df.describe().to_json()
print(summary)

In workflow:

general-purpose:"Create analyze_data.py script":script ->
Bash:"pip install pandas && python3 {script} data.csv":analysis ->
general-purpose:"Interpret {analysis} and create report"

3. Web Scraping

Article Scraper:

// /tmp/workflow-scripts/scraper.js
const axios = require('axios');
const cheerio = require('cheerio');

async function scrapeArticles(url) {
  const {data} = await axios.get(url);
  const $ = cheerio.load(data);

  const articles = [];
  $('.article').each((i, el) => {
    articles.push({
      title: $(el).find('.title').text(),
      url: $(el).find('a').attr('href')
    });
  });

  console.log(JSON.stringify(articles));
}

scrapeArticles(process.argv[2]);

In workflow:

general-purpose:"Create scraper.js":script ->
Bash:"npm install axios cheerio && node {script} https://news.site":articles ->
general-purpose:"Process {articles}"

Script Templates

See script-templates.md for complete library.

Quick templates:

API Client (REST, GraphQL)
Data Processing (CSV, JSON, XML)
Web Scraping (HTML parsing)
File Processing (PDF, images, documents)
Database Access (PostgreSQL, MySQL, MongoDB)
Message Queues (RabbitMQ, Kafka)
Cloud Services (AWS S3, GCS, Azure)

Security Best Practices

See security.md for comprehensive guide.

Quick checklist:

✅ Credentials Management:

Pass via command-line arguments (not hardcoded)
Use environment variables for sensitive data
Clean up after execution

✅ File Permissions:

chmod 700 /tmp/workflow-scripts/script.py  # Owner only

✅ Output Sanitization:

Validate script output before using
Escape special characters
Limit output size

✅ Dependency Management:

Use virtual environments for Python
Specify exact package versions
Avoid running arbitrary code

Integration with Workflows

See integration-patterns.md for detailed patterns.

Pattern 1: Simple Script Execution

general-purpose:"Create script.py that fetches data":script ->
Bash:"python3 {script}":data ->
general-purpose:"Process {data}"

Pattern 2: Script with User Input

AskUserQuestion:"API credentials needed":creds ->
general-purpose:"Create api_client.py with {creds}":script ->
Bash:"python3 {script}":results ->
general-purpose:"Analyze {results}"

Pattern 3: Parallel Script Execution

general-purpose:"Create multiple API clients":scripts ->
[
  Bash:"python3 {scripts.reddit}":reddit_data ||
  Bash:"python3 {scripts.twitter}":twitter_data ||
  Bash:"python3 {scripts.github}":github_data
] ->
general-purpose:"Merge all data sources"

Pattern 4: Iterative Processing

@process_batch ->
general-purpose:"Create batch_processor.py":script ->
Bash:"python3 {script} batch_{n}":results ->
(if results.has_more)~> @process_batch ~>
(if results.complete)~> general-purpose:"Finalize"

Script Directory Structure

/tmp/workflow-scripts/
├── {workflow-id}/              # Unique per workflow
│   ├── reddit_client.py
│   ├── data_processor.py
│   ├── requirements.txt        # Python dependencies
│   ├── package.json            # Node.js dependencies
│   └── .env                    # Environment variables

Automatic cleanup after workflow:

rm -rf /tmp/workflow-scripts/{workflow-id}

Creating Scripts in Workflows

Method 1: Inline Script Creation

general-purpose:"Create Python script:
```python
import requests
import sys

api_key = sys.argv[1]
response = requests.get(
    'https://api.example.com/data',
    headers={'Authorization': f'Bearer {api_key}'}
)
print(response.text)

Save to /tmp/workflow-scripts/api_client.py":script_path ->

Bash:"python3 {script_path} {api_key}":data


### Method 2: Template-Based Creation

```flow
general-purpose:"Use template: api-rest-client
- Language: Python
- API: Reddit
- Auth: Bearer token
- Output: JSON
Create script in /tmp/workflow-scripts/":script ->

Bash:"python3 {script}":data

Method 3: Multi-File Scripts

general-purpose:"Create script package:
- main.py (entry point)
- utils.py (helper functions)
- requirements.txt (dependencies)
Save to /tmp/workflow-scripts/package/":package_path ->

Bash:"cd {package_path} && pip install -r requirements.txt && python3 main.py":data

Dependency Management

Python (pip)

general-purpose:"Create requirements.txt:
requests==2.31.0
pandas==2.0.0
Save to /tmp/workflow-scripts/":deps ->

general-purpose:"Create script.py":script ->

Bash:"pip install -r {deps} && python3 {script}":data

Node.js (npm)

general-purpose:"Create package.json with dependencies":package ->

general-purpose:"Create script.js":script ->

Bash:"cd /tmp/workflow-scripts && npm install && node {script}":data

Virtual Environments

Bash:"python3 -m venv /tmp/workflow-scripts/venv":venv ->

general-purpose:"Create script in venv":script ->

Bash:"source /tmp/workflow-scripts/venv/bin/activate && python3 {script}":data

Error Handling

Capturing Errors

Bash:"python3 {script} 2>&1":output ->

(if output.contains('Error'))~>
  general-purpose:"Parse error: {output}":error ->
  @review-error:"Script failed: {error}" ~>

(if output.success)~>
  general-purpose:"Process {output}"

Retry Logic

@retry ->
Bash:"python3 {script}":result ->

(if result.failed)~>
  general-purpose:"Wait 5 seconds" ->
  @retry ~>

(if result.success)~>
  general-purpose:"Process {result}"

Output Formats

Scripts can return data in various formats:

JSON (Recommended)

import json
result = {"data": [...], "status": "success"}
print(json.dumps(result))

CSV

import csv
import sys
writer = csv.writer(sys.stdout)
writer.writerows(data)

Plain Text

for item in results:
    print(f"{item['title']}: {item['url']}")

Cleanup

Automatic Cleanup

Cleanup happens automatically after workflow completion:

# At end of workflow execution:
general-purpose:"Remove all scripts in /tmp/workflow-scripts/{workflow-id}"

Manual Cleanup

For long-running workflows:

general-purpose:"Create and execute script":result ->
general-purpose:"Process {result}":output ->
Bash:"rm -rf /tmp/workflow-scripts/{script-dir}":cleanup

Best Practices

DO:

✅ Use unique workflow IDs for script directories ✅ Pass credentials as arguments, not hardcoded ✅ Validate and sanitize script output ✅ Use virtual environments for Python ✅ Specify exact dependency versions ✅ Return structured data (JSON preferred) ✅ Clean up after workflow completion ✅ Set restrictive file permissions ✅ Use timeouts for script execution ✅ Log script output for debugging

DON'T:

❌ Hardcode API keys in scripts ❌ Execute untrusted code ❌ Store sensitive data in script files ❌ Leave scripts after workflow ❌ Use global Python/Node packages ❌ Ignore script errors ❌ Return massive outputs (>1MB) ❌ Use system-wide directories

Tips for Effective Script Management

Use Descriptive Names: reddit_api_client.py not script.py
Return Structured Data: Always use JSON when possible
Error Messages: Include detailed error messages in output
Logging: Add logging for debugging:

import logging
logging.basicConfig(level=logging.INFO)
logging.info(f"Fetching data from {url}")

Validation: Validate inputs before execution
Timeouts: Set execution timeouts:

Bash:"timeout 30 python3 {script}":data

Related Skills

creating-workflows: Create workflows that use temp scripts
executing-workflows: Execute workflows with script steps
managing-agents: Temp agents vs temp scripts
debugging-workflows: Debug script execution issues

Advanced Topics

See detail files for:

script-lifecycle.md - Complete lifecycle management
script-templates.md - 20+ ready-to-use templates
security.md - Security best practices
integration-patterns.md - Workflow integration patterns

Ready to use temporary scripts? Just describe what API or processing you need!

Source: mbruhler/claude-orchestration — distributed by TomeVault.

Managing Temp Scripts

File contents

Managing Temporary Scripts

When I Activate

Key Concept

Quick Example

Script Lifecycle

Common Use Cases

1. API Integration

2. Data Processing

3. Web Scraping

Script Templates

Security Best Practices

Integration with Workflows

Pattern 1: Simple Script Execution

Pattern 2: Script with User Input

Pattern 3: Parallel Script Execution

Pattern 4: Iterative Processing

Script Directory Structure

Creating Scripts in Workflows

Method 1: Inline Script Creation

Method 3: Multi-File Scripts

Dependency Management

Python (pip)

Node.js (npm)

Virtual Environments

Error Handling

Capturing Errors

Retry Logic

Output Formats

JSON (Recommended)

CSV

Plain Text

Cleanup

Automatic Cleanup

Manual Cleanup

Best Practices

DO:

DON'T:

Tips for Effective Script Management

Related Skills

Advanced Topics

Related skills

Frequently asked questions

How do I install the Managing Temp Scripts skill?

What does the Managing Temp Scripts skill do?

Is Managing Temp Scripts safe to use?

Which AI agents work with Managing Temp Scripts?

Is Managing Temp Scripts free to use?

Who published Managing Temp Scripts?