1215656 Clawdbot Filesystem@1.0.2

Advanced filesystem operations - listing, searching, batch processing, and directory analysis for Clawdbot

Security Scan

The skill's declared purpose (filesystem operations) matches the instructions, but multiple metadata and installation inconsistencies (missing binaries, conflicting permission/allowed-paths entries, and unclear install source) make it risky until you verify the provenance and actual executable code.

Purpose & Capability

The skill's name, README and SKILL.md describe filesystem listing, searching, copying and analysis — which matches the required 'node' binary and the expected capabilities. However, the bundled metadata contains contradictory claims about permissions (package.json/clawdbot permissions show read-write access; skill.json describes '高权限' and an AllowedPaths list limited to a single Windows workspace) and main/bin entries point at files that are not present. These mismatches reduce confidence that the manifest accurately represents the skill's real behavior.

Instruction Scope

SKILL.md confines actions to filesystem operations (listing, searching, copying, analyzing) and documents safety features (path validation, dry-run, protected paths). That scope is appropriate for a filesystem tool. Concerns: instructions expect a 'filesystem' CLI to be present and instruct users to clone/run an external repo (git clone <filesystem-skill-repo> then chmod +x filesystem). The SKILL.md also contains examples operating on system paths (/var/log, /etc), so the skill legitimately needs wide filesystem access — but those operations should only be allowed with explicit, auditable code that you can inspect first.

Install Mechanism

There is no formal install spec in the registry entry (instruction-only). The docs suggest cloning a repository and making a 'filesystem' binary executable, but the packaged files do not include the binary or any runtime JS (no index.js, no filesystem script). package.json references a './filesystem' bin and main entry, but that file is missing. This gap means an installer or user would be asked to fetch code from an external source at install time — a high-risk step unless the URL and repository contents are verified.

Credentials

No environment variables or external credentials are requested (good). However, multiple manifest entries claim broad filesystem privileges ('filesystem': 'read-write' in package.json, and skill.json claims read/write and references allowedPaths/deniedPaths). Those permission claims are broader than what a minimal listing/search tool strictly needs, and they conflict (SKILL.md/config.json protectedPaths vs skill.json allowedPaths). The owner IDs in registry metadata, _meta.json and package metadata do not match — another provenance inconsistency to resolve before granting filesystem access.

Persistence & Privilege

The skill is not marked always:true (good) and autonomous invocation is allowed (platform default). The concern is metadata claiming high filesystem privileges and read-write capability while the package lacks the actual executable. If installed by cloning an external repo, that code could persist on disk with read/write ability. Because of the manifest/packaging inconsistencies, treat privilege claims as unverified until you inspect the actual code to be installed.

Scan Findings in Context

[no_findings] expected: The regex-based scanner found nothing to analyze because this package contains no runtime code files (only docs and metadata). That absence of findings is insufficient evidence of safety — it simply means there was nothing for the scanner to inspect.

What to consider before installing

Do not install or run this skill as-is. Before using it, verify provenance and contents of the runtime binary: 1) Confirm the authoritative repository URL (do not clone a placeholder URL). 2) Inspect the actual 'filesystem' executable or index.js in a secure environment (ideally inside a disposable VM or container) and review its source for network calls, shell exec, or credential access. 3) Reconcile manifest inconsistencies (owner IDs, version, skill.json allowedPaths vs README examples, missing bin/main files). 4) If you need similar functionality, prefer an implementation that ships its executable in the package or is published on an audited registry, and restrict its allowedPaths to the minimal directories required. 5) If you proceed, run the tool with least privilege, enable dry-run mode first, and monitor file operations. If you are unsure, consider refusing installation until the author/source is validated.

📁 Filesystem Management

Advanced filesystem operations for AI agents. Comprehensive file and directory operations with intelligent filtering, searching, and batch processing capabilities.

Features

📋 Smart File Listing

• Advanced Filtering - Filter by file types, patterns, size, and date
• Recursive Traversal - Deep directory scanning with depth control
• Rich Formatting - Table, tree, and JSON output formats
• Sort Options - By name, size, date, or type

🔍 Powerful Search

• Pattern Matching - Glob patterns and regex support
• Content Search - Full-text search within files
• Multi-criteria - Combine filename and content searches
• Context Display - Show matching lines with context

🔄 Batch Operations

• Safe Copying - Pattern-based file copying with validation
• Dry Run Mode - Preview operations before execution
• Progress Tracking - Real-time operation progress
• Error Handling - Graceful failure recovery

🌳 Directory Analysis

• Tree Visualization - ASCII tree structure display
• Statistics - File counts, size distribution, type analysis
• Space Analysis - Identify large files and directories
• Performance Metrics - Operation timing and optimization

Quick Start

# List files with filtering
filesystem list --path ./src --recursive --filter "*.js"

# Search for content
filesystem search --pattern "TODO" --path ./src --content

# Batch copy with safety
filesystem copy --pattern "*.log" --to ./backup/ --dry-run

# Show directory tree
filesystem tree --path ./ --depth 3

# Analyze directory structure
filesystem analyze --path ./logs --stats

Command Reference

filesystem list

Advanced file and directory listing with filtering options.

Options:

• --path, -p <dir> - Target directory (default: current)
• --recursive, -r - Include subdirectories
• --filter, -f <pattern> - Filter files by pattern
• --details, -d - Show detailed information
• --sort, -s <field> - Sort by name|size|date
• --format <type> - Output format: table|json|list

filesystem search

Search files by name patterns or content.

Options:

• --pattern <pattern> - Search pattern (glob or regex)
• --path, -p <dir> - Search directory
• --content, -c - Search file contents
• --context <lines> - Show context lines
• --include <pattern> - Include file patterns
• --exclude <pattern> - Exclude file patterns

filesystem copy

Batch copy files with pattern matching and safety checks.

Options:

• --pattern <glob> - Source file pattern
• --to <dir> - Destination directory
• --dry-run - Preview without executing
• --overwrite - Allow file overwrites
• --preserve - Preserve timestamps and permissions

filesystem tree

Display directory structure as a tree.

Options:

• --path, -p <dir> - Root directory
• --depth, -d <num> - Maximum depth
• --dirs-only - Show directories only
• --size - Include file sizes
• --no-color - Disable colored output

filesystem analyze

Analyze directory structure and generate statistics.

Options:

• --path, -p <dir> - Target directory
• --stats - Show detailed statistics
• --types - Analyze file types
• --sizes - Show size distribution
• --largest <num> - Show N largest files

Installation

# Clone or install the skill
cd ~/.clawdbot/skills
git clone <filesystem-skill-repo>

# Or install via ClawdHub
clawdhub install filesystem

# Make executable
chmod +x filesystem/filesystem

Configuration

Customize behavior via config.json:

{
  "defaultPath": "./",
  "maxDepth": 10,
  "defaultFilters": ["*"],
  "excludePatterns": ["node_modules", ".git", ".DS_Store"],
  "outputFormat": "table",
  "dateFormat": "YYYY-MM-DD HH:mm:ss",
  "sizeFormat": "human",
  "colorOutput": true
}

Examples

Development Workflow

# Find all JavaScript files in src
filesystem list --path ./src --recursive --filter "*.js" --details

# Search for TODO comments
filesystem search --pattern "TODO|FIXME" --path ./src --content --context 2

# Copy all logs to backup
filesystem copy --pattern "*.log" --to ./backup/logs/ --preserve

# Analyze project structure
filesystem tree --path ./ --depth 2 --size

System Administration

# Find large files
filesystem analyze --path /var/log --sizes --largest 10

# List recent files
filesystem list --path /tmp --sort date --details

# Clean old temp files
filesystem list --path /tmp --filter "*.tmp" --older-than 7d

Safety Features

• Path Validation - Prevents directory traversal attacks
• Permission Checks - Verifies read/write access before operations
• Dry Run Mode - Preview destructive operations
• Backup Prompts - Suggests backups before overwrites
• Error Recovery - Graceful handling of permission errors

Integration

Works seamlessly with other Clawdbot tools:

• Security Skill - Validates all filesystem operations
• Git Operations - Respects .gitignore patterns
• Backup Tools - Integrates with backup workflows
• Log Analysis - Perfect for log file management

Updates & Community

Stay informed about the latest Clawdbot skills and filesystem tools:

• 🐦 Follow @LexpertAI on X for skill updates and releases
• 🛠️ New filesystem features and enhancements
• 📋 Best practices for file management automation
• 💡 Tips and tricks for productivity workflows

Get early access to new skills and improvements by following @LexpertAI for:

• Skill announcements and new releases
• Performance optimizations and feature updates
• Integration examples and workflow automation
• Community discussions on productivity tools

License

MIT License - Free for personal and commercial use.

---

Remember: Great filesystem management starts with the right tools. This skill provides comprehensive operations while maintaining safety and performance.