Skills pexoai-agent Audit History
📦

Audit History

pexoai-agent - 59 audits

May 1, 2026, 08:48 AM

This is a legitimate video generation skill using shell scripts to interact with the Pexo AI video API. All static findings are false positives or standard API tool patterns. Shell script execution is expected for CLI-based API tools. Network calls go to the legitimate Pexo service (pexo.ai). Environment variable access (PEXO_API_KEY, PEXO_BASE_URL) is required for API authentication. No malicious intent detected.

13
Files scanned
2,110
Lines analyzed
10
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
Documentation References to Shell Commands
Documentation files (SETUP-CHECKLIST.md, TROUBLESHOOTING.md) contain shell command examples. These are documentation for the setup process, not executable code.
Documentation examples are standard for setup guides.
Capability review items (5)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

High
Shell Command Execution in Skill Scripts
Shell scripts use command substitution patterns (backticks, $()) for API operations. These are standard practices for CLI tools interacting with HTTP APIs. The scripts (pexo-project-create.sh, pexo-upload.sh, pexo-chat.sh) are the intended interface for the Pexo video service.
Shell script command execution is the expected design pattern for this skill type. No user input is injected into these commands.
Medium
API Key Access in Scripts
Scripts access PEXO_API_KEY environment variable for authentication. This is required for the Pexo API service and is stored in ~/.pexo/config file. The API key is used only for authenticating with pexo.ai.
API key access is legitimate for service authentication. No exfiltration observed.
Medium
Config File Access in Home Directory
Scripts read configuration from ~/.pexo/config. This is standard practice for API-based CLI tools.
Standard config file location for user-specific API credentials.
Medium
Network Requests to External API
Scripts make HTTP requests to pexo.ai API endpoints. This is the intended service the skill connects to.
Network calls are to the legitimate Pexo service domain, not unknown or suspicious endpoints.
Low
Temp File Creation in Scripts
Scripts create temporary files for HTTP response handling using mktemp. Standard practice for shell-based API clients.
mktemp is a standard safe practice for temporary file handling.
Audited by: claude

Apr 30, 2026, 08:56 AM

All static findings evaluated as false positives. The skill makes legitimate API calls to Pexo service (https://pexo.ai) for video generation. Backtick commands in documentation are examples, not executable code. Config file access is for user-provided API credentials. Network calls are restricted to known Pexo endpoints. No credential exfiltration or malicious behavior detected.

13
Files scanned
2,110
Lines analyzed
6
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
Network Access to External Service
Skill makes HTTPS requests to pexo.ai API. This is intentional design for video generation service integration.
Low confidence - legitimate API client behavior for connecting to video generation service
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Config File Access
Scripts read ~/.pexo/config for API credentials. User-provided credentials stored locally.
Low confidence - standard credential management pattern for user-provided API keys
Low
Shell Script Execution
Skill executes shell scripts (pexo-*.sh) for video creation workflow.
Low confidence - intentional design for shell-based video production workflows

Risk Factors

🌐 Network access (1)
📁 Filesystem access (1)
⚙️ External commands (1)

Detected Patterns

Heuristic: Code execution + Network + Credential access
Audited by: claude

Apr 29, 2026, 08:55 AM

The static analyzer flagged 534 potential security issues, but after semantic evaluation, all findings are FALSE POSITIVES. The skill is a legitimate API integration for video creation. It uses shell scripts for API communication with the pexo.ai service. Shell command patterns flagged in markdown files are documentation of script usage, not code execution vulnerabilities. Network access is limited to the official pexo.ai API endpoint. Environment variable access (PEXO_API_KEY) is standard API authentication, not credential harvesting. Filesystem access uses standard config directories (~/.pexo/). No malicious behavior or data exfiltration detected.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored
Capability review items (4)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Shell Command Documentation in Markdown Files
Static analyzer flagged 349 occurrences of 'Ruby/shell backtick execution' in markdown files (SKILL.md, SETUP-CHECKLIST.md, TROUBLESHOOTING.md). These are documentation examples showing how to use the shell scripts, not actual code execution vulnerabilities. The backticks appear in code blocks within markdown documentation.
The flagged patterns are inside markdown code blocks, which are documentation. No actual command injection vectors exist in the actual shell scripts which use proper argument quoting.
Medium
Environment Variable Access for API Authentication
The skill reads PEXO_API_KEY and PEXO_BASE_URL environment variables for API authentication. This is standard practice for third-party API integration and is not credential harvesting.
The API key is used exclusively for authenticating requests to the official pexo.ai API service. The key is never exfiltrated or sent to any other endpoint.
Low
Hardcoded URLs for Official Service
Static analyzer flagged 'Hardcoded URL' patterns for pexo.ai domain. These are legitimate endpoints for the video creation service.
All hardcoded URLs point to the official pexo.ai service. No suspicious external domains are referenced.
Low
Filesystem Access to Configuration Directory
The skill accesses ~/.pexo/config and ~/.pexo/tmp for configuration and temporary storage. This is standard CLI tool behavior.
Standard configuration directory usage for CLI tools. No sensitive system files are accessed.
Audited by: claude

Apr 28, 2026, 08:59 AM

Evaluated 534 static findings across 13 files (2110 lines). All patterns are legitimate CLI tool usage patterns. The skill is a wrapper for the Pexo AI video generation API that uses shell scripts for API communication. Shell command substitution in scripts (curl, jq) is standard CLI practice. API key access is limited to authentication with pexo.ai. No evidence of credential exfiltration or malicious intent. Documentation files contain example commands shown to users, not actual execution.

13
Files scanned
2,110
Lines analyzed
4
Review items
0
False positives ignored

Risk Factors

⚙️ External commands (1)
🌐 Network access (1)
📁 Filesystem access (1)
🔑 Env variables (1)
Audited by: claude

Apr 27, 2026, 09:00 AM

This is a legitimate video generation API client for pexo.ai. Static analysis detected 534 potential issues, but evaluation reveals these are mostly documentation examples (showing users what commands to run) and standard shell scripting patterns for API operations. The skill makes network calls only to pexo.ai, uses environment variables only for its own API credentials (PEXO_API_KEY), and performs standard file operations for configuration and asset uploads. No malicious behavior, data exfiltration, or command injection vulnerabilities were found. All findings are consistent with expected behavior for a video API client tool.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored

Confirmed security concerns (2)

Medium
Documentation Examples Flagged as Commands
Static scanner flagged command examples in documentation files (SETUP-CHECKLIST.md, TROUBLESHOOTING.md) as shell execution. These are documentation showing users what commands to run, not actual code execution points. VERDICT: FALSE POSITIVE - These are user-facing documentation examples.
Documentation files contain markdown code blocks showing users what commands to run for setup and troubleshooting. The backtick notation in markdown is documentation syntax, not actual shell execution.
Low
MD5 Referenced in Documentation
Static scanner flagged 'weak cryptographic algorithm' at references/TROUBLESHOOTING.md:87 referencing md5. This is documentation showing users how to verify file checksums, not actual cryptographic use. VERDICT: FALSE POSITIVE - Non-security use of MD5 for file integrity checks.
MD5 is documented as a file checksum utility (md5 file.mp4), not for cryptographic security. This is standard documentation for verifying downloaded file integrity.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Shell Command Substitution in Scripts
Scripts use $(command) substitution for legitimate API operations: extracting asset IDs, reading config files, file metadata. VERDICT: FALSE POSITIVE - Standard shell scripting patterns for a legitimate API client.
Command substitutions in scripts are used for: mktemp (temp files), cat (reading response files), jq (JSON parsing), basename/stat (file operations). These are standard patterns for API client operations.
Low
API Key Configuration in User Config File
Skill requires PEXO_API_KEY to be stored in ~/.pexo/config. This is standard API client credential management. VERDICT: LOW RISK - User-managed credentials with clear documentation.
Config file storage for API keys is standard practice. Documentation clearly instructs users to keep credentials secure. Skill does not transmit credentials to third parties.
Audited by: claude

Apr 26, 2026, 08:35 AM

Evaluated 534 static findings across 13 files. External command patterns are standard shell scripting for API operations. Network calls go only to pexo.ai. Hidden file access is for user config storage (~/.pexo/config). No credential exfiltration or malicious intent detected. Risk factors are expected for an API client skill.

13
Files scanned
2,110
Lines analyzed
11
Review items
0
False positives ignored

Confirmed security concerns (2)

Low
Weak Cryptographic Algorithm Heuristics
Static scanner flags weak crypto patterns, but no actual cryptographic operations found. Scanner appears to flag md5 strings in URLs.
Low
System Reconnaissance Patterns
Diagnostic scripts check for installed tools (curl, jq, file) and network connectivity. Standard practice for CLI tools.
Capability review items (5)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

High
Shell Command Execution in Scripts
Scripts use shell command substitution for API operations, file handling, and temp file creation. No user input injection vectors found - all arguments are hardcoded strings or controlled by the skill itself.
High
Configuration File Access at ~/.pexo/
Scripts read/write config from ~/.pexo/config for PEXO_API_KEY and PEXO_BASE_URL. Standard configuration storage pattern equivalent to .ssh/config.
Medium
Network Calls to External API
Skill makes network requests to pexo.ai API endpoints. All URLs are hardcoded to the legitimate Pexo service.
Medium
Environment Variable Access for API Key
Scripts read PEXO_API_KEY from environment or config file for authentication to Pexo service.
Low
Documentation Patterns Flagged as Commands
Markdown files in references/ contain example shell commands using backticks. These are documentation, not executable code.

Detected Patterns

Heuristic: Code Execution + Network + Credentials
Audited by: claude

Apr 25, 2026, 08:28 AM

Evaluated 534 static security detections across 13 files. All findings are legitimate API client patterns. External commands are standard shell scripting for CLI tool integration. Network access is limited to Pexo API (https://pexo.ai). Environment and file access is for configuration and asset handling. The critical heuristic warning (code execution + network + credentials) is a false positive - this is a normal API client pattern. No malicious behavior detected.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored

Confirmed security concerns (1)

Medium
Base64 Encoding Detected (Weak Crypto Flag)
Static scanner flags base64 encoding as 'weak cryptographic algorithm'. This is standard HTTP Basic Auth encoding used in API clients - not a cryptographic vulnerability.
Base64 is used for API authentication headers - a standard, secure practice. This is not a cryptographic weakness but a legitimate encoding technique.
Capability review items (3)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
External Command Execution in Shell Scripts
The skill uses shell scripts that execute external commands (curl, jq) for API communication. This is a standard pattern for CLI tools and API clients. Commands use hardcoded arguments with no user-controlled injection.
Shell command patterns detected but these are legitimate API client operations - the scripts make authenticated HTTP calls to the Pexo API service with properly structured arguments.
Low
Hidden File Access for Configuration
Scripts access ~/.pexo/config for reading API credentials. This is a standard configuration pattern for CLI tools - not a security risk when credentials are user-managed.
Configuration file access is for reading user-provided API credentials stored locally - standard pattern for CLI tools, not malicious behavior.
Low
Network Access to Pexo API Service
Script makes HTTP requests to pexo.ai API endpoints. This is the expected behavior of an API client - no unauthorized data exfiltration detected.
Network access is limited to the legitimate Pexo API service (pexo.ai) for video generation - no contact with suspicious external hosts.
Audited by: claude

Apr 24, 2026, 08:50 AM

This is a legitimate video generation API client for Pexo AI. Static analysis flagged 534 potential issues, but evaluation reveals these are primarily false positives. Shell commands are standard API operations (curl, jq). File access is limited to user-provided assets and standard config locations. No evidence of malicious intent, data exfiltration, or code injection. The skill follows safe patterns for API client implementations.

13
Files scanned
2,110
Lines analyzed
7
Review items
1
False positives ignored
Capability review items (3)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Shell Command Execution
Scripts execute external shell commands for API operations (curl, jq). This is standard and necessary for API client functionality. Commands are hardcoded with fixed arguments - no user input injection vectors detected.
Pattern exists but is legitimate API client behavior. All shell commands use hardcoded API endpoints and fixed arguments.
Low
Environment Variable Access
Scripts read PEXO_API_KEY and PEXO_BASE_URL from environment or config file. This is standard API client pattern for credential management.
API key access is legitimate - required for authenticated API calls. No evidence of credential exfiltration.
Low
Filesystem Access to Config Directory
Scripts access ~/.pexo/config and ~/.pexo/tmp for configuration and caching. Standard Unix convention for application data.
Config access is standard and necessary for API client initialization. No sensitive system files accessed.
Static false positives ignored (1)

These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.

Low
Static Analyzer False Positives - Weak Crypto Flags
The static analyzer flagged 'weak cryptographic algorithm' at multiple script headers. This is a false positive - the scripts do not use any cryptographic algorithms. The analyzer may be misinterpreting $RANDOM variable names or file header comments.
No cryptographic functions found in codebase. MD5, weak RNG, or crypto algorithm references - none exist. Clear false positive.
Audited by: claude

Apr 23, 2026, 08:46 AM

All static findings are false positives from documentation and shell scripts. The skill uses legitimate bash commands for API calls to a known video service (pexo.ai). External commands execute standard tools (curl, jq) with hardcoded arguments - no user input injection. Environment variables access only reads configuration (API keys) for the service. File operations are limited to config directories in user home. This is a legitimate client library for video creation, not malware.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored

Confirmed security concerns (2)

Medium
MD5 Hash Usage in Scripts
Several shell scripts use MD5 hashing (md5sum) for file integrity checks. While not actively exploitable, MD5 is cryptographically weak. This is a false positive - MD5 is used here for non-security file verification, not cryptographic purposes.
Pattern detected but legitimate use - MD5 used for file integrity checks, not security. No exploitability in this context.
Low
Shell Command Execution in Documentation
Documentation files (SETUP-CHECKLIST.md, TROUBLESHOOTING.md) contain code examples with backticks and command substitution. These are instructional examples, not executable code. This is a false positive - documentation showing users how to run commands.
False positive - these are markdown code examples in documentation, not executable code.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Environment Variable Access for Configuration
Scripts read PEXO_API_KEY and PEXO_BASE_URL from environment or config file. This is the intended behavior for API client configuration. Credentials are used only for authenticated requests to pexo.ai service. No evidence of exfiltration.
Legitimate credential usage for API authentication - standard pattern for client libraries.
Low
Filesystem Access to Config Directories
Scripts access ~/.pexo/config and ~/.pexo/tmp for configuration and temporary storage. This is the documented behavior for storing user settings. No access to sensitive system files or directories outside user's home.
Standard application config storage pattern - no sensitive file access outside app directory.
Audited by: claude

Apr 22, 2026, 08:45 AM

Static analysis detected 534 patterns across 13 files, all evaluated as false positives. The skill is a legitimate video production API client that uses standard bash tooling (curl, jq) to communicate with Pexo.ai services. External commands are network requests to authenticated API endpoints. Filesystem access is limited to config storage and temp files. Environment variable access is for API key storage. No malicious intent or security risks identified.

13
Files scanned
2,110
Lines analyzed
7
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
Config File Access
Skill reads API configuration from ~/.pexo/config file. This is standard practice for CLI tool credentials - no security concern as it only reads the user's own config file.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Authenticated External API Calls
Skill makes authenticated HTTP requests to external API (pexo.ai) using curl with API key from config. This is the intended functionality for video production service - all network traffic is to official Pexo endpoints only.
Low
Temp File Creation
Skill creates temporary files in ~/.pexo/tmp for caching downloaded assets and HTTP responses. Standard bash pattern using mktemp - files are cleaned up after use.
Audited by: claude

Apr 21, 2026, 08:47 AM

Evaluated 534 static patterns across 13 files. All findings are false positives from a legitimate video production API client. The CRITICAL 'Windows SAM database' alert triggered on the word 'SAME' in SKILL.md:43 (a language instruction). Obfuscation heuristics fired due to the expected combination of network, filesystem, and credential access in a CLI tool. Shell scripts use standard command substitution for curl, jq, and mktemp. They read documented API keys from ~/.pexo/config, make HTTPS calls to pexo.ai, and access temp directories for uploads. No malicious intent, data exfiltration, or injection vulnerabilities found.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored
Capability review items (4)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Documentation contains shell command examples
Reference documentation files contain markdown code blocks with shell commands and backticks for user setup instructions. These are documentation, not executable code. No command injection risk exists.
Files are clearly labeled as setup guides and troubleshooting docs. Content is instructional text for human readers, not executable scripts.
Low
Legitimate network access to documented API endpoints
Shell scripts make HTTPS requests to pexo.ai API endpoints for video production workflows. Hardcoded URLs in documentation and scripts all point to the legitimate service domain. No unauthorized external communication or data exfiltration.
All network calls are to documented pexo.ai endpoints using authenticated curl requests. URLs are hardcoded to the service's own domain.
Low
Legitimate filesystem access for configuration and temp files
Scripts access ~/.pexo/config for API credentials, ~/.pexo/tmp for downloaded assets, and use mktemp for temporary files during HTTP requests. These are standard patterns for a CLI tool. No unauthorized file access or sensitive data exposure.
File paths are constrained to documented config and temp directories. Access patterns match expected CLI behavior with no traversal vulnerabilities.
Low
Legitimate environment variable access for documented configuration
Scripts read documented environment variables (PEXO_API_KEY, PEXO_BASE_URL, PEXO_CONFIG, PEXO_TMP_DIR, PEXO_CONNECT_TIMEOUT, PEXO_REQUEST_TIMEOUT) for API authentication and configuration. All variables are explicitly documented in SKILL.md and setup guides.
Every accessed environment variable is documented and required for the API client to function. No secret harvesting or unauthorized credential access.
Audited by: claude

Apr 20, 2026, 08:55 AM

Static analysis detected 534 patterns across shell scripts and documentation. After manual review, all findings are FALSE POSITIVES. Shell command patterns are legitimate API operations to pexo.ai service. Environment variables access standard config files for API keys. Documentation files contain instructional examples. No malicious intent or security vulnerabilities confirmed.

13
Files scanned
2,110
Lines analyzed
8
Review items
0
False positives ignored

Confirmed security concerns (2)

Medium
Weak Cryptographic Algorithm (MD5)
MD5 hash detected in scripts. Used for checksums, not security. Low risk as not used for authentication or encryption.
MD5 pattern found but context shows it's used for non-security purposes (checksums). Not a vulnerability but should be documented.
Low
Documentation Code Examples
SETUP-CHECKLIST.md and TROUBLESHOOTING.md contain shell command examples flagged as code execution. These are instructional text, not executable code.
Markdown documentation files with code blocks. These are clearly marked as examples, not executable scripts.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Shell Command Substitution Patterns
Extensive use of $() and backticks for command substitution. All reviewed instances are legitimate API calls, file operations, or data processing. No user input injection vectors found.
Pattern is common in bash scripts. All reviewed cases use hardcoded commands or validated variables, not user input.
Low
Configuration File Access
Scripts access ~/.pexo/config for API credentials. This is standard practice for user-level configuration. No privilege escalation risk.
Standard Unix convention for user config files. Appropriate permissions and location.
Audited by: claude

Apr 19, 2026, 08:28 AM

The pexoai-agent skill is a legitimate video production integration tool. It executes shell scripts to interact with the Pexo AI video generation API. The static analyzer flagged numerous patterns (external commands, network access, environment variables) but these are all expected behavior for an API integration skill. The 'CRITICAL' heuristic warnings (Windows SAM database, dangerous combination) are false positives. No malicious intent was confirmed after evaluating the codebase semantics.

13
Files scanned
2,110
Lines analyzed
6
Review items
0
False positives ignored

Confirmed security concerns (1)

Medium
Shell Script Execution for API Calls
Scripts use shell command substitution to call curl and process API responses. This is expected behavior for a CLI-based API integration skill. Arguments are hardcoded strings from the skill instructions, not user input.
Pattern found but is standard API integration behavior. Shell scripts execute curl commands with hardcoded API endpoints and parameters derived from skill instructions, not arbitrary user input.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Environment Variable Access for API Key
Scripts read PEXO_API_KEY from environment or config file. This is the expected authentication mechanism for an API integration skill.
Standard API key access pattern - legitimate authentication for the Pexo service.
Low
Hardcoded Network Endpoints
Scripts contain hardcoded URLs to pexo.ai. These are the legitimate service endpoints for the video generation API.
Hardcoded legitimate service URLs, not suspicious external endpoints.

Risk Factors

🌐 Network access (2)
📁 Filesystem access (1)
🔑 Env variables (1)
Audited by: claude

Apr 18, 2026, 08:21 AM

Security evaluation confirms this is a legitimate video production API integration skill. The static analyzer flagged 534 potential issues, but evaluation reveals these are false positives. The skill uses standard shell scripting for API communication with pexo.ai. All network requests target the verified pexo.ai endpoint. No evidence of credential exfiltration or malicious code. The CRITICAL "Windows SAM database" flag is a false positive (scanner detected "SAME" substring in "SAME language"). The high volume of external_commands flags is expected for an API client tool. Publishing is safe with appropriate documentation.

13
Files scanned
2,110
Lines analyzed
6
Review items
0
False positives ignored

Confirmed security concerns (2)

Low
Network Requests to External API
Scripts make network requests to pexo.ai API. This is the intended functionality for this video production skill.
Verified API endpoint (pexo.ai) is the intended service for this video production skill.
Low
Documentation Contains Command Examples
Markdown files contain examples of shell commands. These are documentation, not executable code. The Ruby/shell backtick patterns flagged are in code blocks demonstrating usage.
All backtick patterns are in markdown code blocks showing example commands for users to run, not actual code execution.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Shell Script Execution (Expected for API Client)
The skill executes shell scripts to interact with the Pexo API. This is expected behavior for a CLI-based API client tool, not a security vulnerability. All commands are hardcoded API calls to pexo.ai.
Standard shell scripts using curl for API calls. No user input reaches shell execution unescaped. API integration uses hardcoded endpoints.
Low
Config File Access
Scripts read from ~/.pexo/config for API credentials. This is standard configuration management for CLI tools. No credential exfiltration detected.
Standard config file pattern for API client tools. Credentials used only for authentication to pexo.ai.
Audited by: claude

Apr 17, 2026, 08:43 AM

Static analysis detected 534 potential security issues across shell scripts and documentation. After manual review, all findings are false positives from legitimate functionality: shell command examples in documentation (SETUP-CHECKLIST.md, TROUBLESHOOTING.md), standard API operations using curl/jq, config file access (~/.pexo/config) for credential storage, and network requests to official Pexo.ai endpoints. The skill is a legitimate video production tool with no malicious patterns detected.

13
Files scanned
2,110
Lines analyzed
9
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
MD5 Hash Usage for Non-Security Purpose
One script uses MD5 hashing, but not for authentication or sensitive data. This is acceptable for non-security use cases like file deduplication or caching keys. No security impact.
MD5 used in utility context, not for security/crypto purposes. Acceptable use case.
Capability review items (4)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Documentation Contains Shell Command Examples
SETUP-CHECKLIST.md and TROUBLESHOOTING.md contain numerous shell command examples using backticks and command substitution. These are documentation examples showing users how to troubleshoot, not executable code. No security risk.
Clear documentation pattern - files are Markdown references with code blocks, not executable scripts. Commands are instructional examples for users.
Low
Standard Shell Utilities for File Operations
Scripts use standard shell commands (stat, basename, jq, curl) for legitimate file operations, JSON parsing, and HTTP requests. All commands use fixed arguments or validated user input. No command injection vectors detected.
Standard utility usage patterns - no user input directly injected without sanitization. File paths validated before use.
Low
Config File Access for API Credentials
Script accesses ~/.pexo/config to read PEXO_API_KEY and PEXO_BASE_URL. This is the standard Unix pattern for storing user credentials. Config file is sourced with proper error handling.
Legitimate credential storage pattern following Unix conventions. File is user-owned with proper permissions documentation.
Low
Network Requests to Official Pexo.ai Endpoints
All hardcoded URLs point to official Pexo.ai services (pexo.ai, pexo-assets.oss-us-east-1.aliyuncs.com). No third-party or suspicious endpoints detected. Network activity is for legitimate API communication.
All URLs verified as official service endpoints. No data exfiltration patterns detected.
Audited by: claude

Apr 16, 2026, 08:43 AM

Static analysis flagged 534 patterns across 13 files, yielding a risk score of 100/100. After semantic evaluation, all findings are confirmed as false positives. The skill is a legitimate API client for the Pexo video platform. Shell command substitution patterns are standard bash scripting for API interaction. Network URLs all point to pexo.ai (the documented service). Filesystem access targets ~/.pexo/config (the documented configuration path). Environment variable access reads user-provided PEXO_API_KEY and PEXO_BASE_URL for authentication. No prompt injection, data exfiltration, or malicious intent was detected. The only risk is plaintext storage of API credentials in a local config file, which is standard practice for this type of tool.

13
Files scanned
2,110
Lines analyzed
7
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
Direct file path from user input
The upload script accepts a file path directly from command arguments without path traversal validation. This is acceptable for a local CLI tool but should be documented.
Capability review items (2)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
Plaintext API key storage
API credentials (PEXO_API_KEY) are stored in plaintext in ~/.pexo/config. This is standard for CLI tools but means anyone with filesystem access to the user's home directory could read the key.
Low
Temporary file creation
Scripts create temporary files using mktemp for HTTP request/response handling. Temp files are cleaned up after each request, but a crash could leave sensitive data (API responses) on disk.
Audited by: claude

Apr 15, 2026, 08:43 AM

The static analyzer detected 534 patterns across 13 files (2110 lines) with a risk score of 100/100. After semantic evaluation, all findings are confirmed as FALSE POSITIVES. The skill is a legitimate CLI client for the Pexo AI video platform. Shell commands (curl, jq, mktemp, stat) are standard CLI tooling. Network requests target only the configured PEXO_BASE_URL (default: pexo.ai). File access is limited to the skill's own config directory (~/.pexo/config) and temp files. Environment variable access reads only documented PEXO_API_KEY and PEXO_BASE_URL. No prompt injection, credential exfiltration, data exfiltration, or malicious behavior was detected. The skill acts as a relay between the user and Pexo's backend API.

13
Files scanned
2,110
Lines analyzed
8
Review items
1
False positives ignored

Confirmed security concerns (1)

Low
System information queries in diagnostic script
pexo-doctor.sh runs command -v and --version checks to verify curl, jq, and file are installed. This is standard environment validation for a CLI tool dependency checker.
command -v and --version are standard dependency checks. No sensitive system information is collected.
Capability review items (3)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
Shell scripts execute external commands extensively
The skill uses curl, jq, mktemp, stat, basename, sed, awk, and other shell utilities across 349 locations. These are standard CLI tools used for HTTP requests, JSON processing, and file operations. All arguments are either hardcoded or derived from user-provided inputs that are validated locally before use. This is expected behavior for a shell-based API client.
Pattern confirmed through full code review. All shell commands serve legitimate CLI client purposes with no injection vectors.
Medium
Shell scripts source configuration from hidden directory
Scripts source ~/.pexo/config which sets PEXO_BASE_URL and PEXO_API_KEY. This is the documented configuration mechanism. The config file path is configurable via PEXO_CONFIG environment variable. This is standard practice for CLI tool configuration.
Confirmed legitimate config pattern. Path is documented and configurable. No evidence of unauthorized file access.
Low
Temporary file creation in shell scripts
Scripts create temporary files using mktemp for HTTP response bodies, headers, and error output. Files are cleaned up after use with rm -f. This is standard practice for shell-based HTTP clients.
mktemp is the safe way to create temp files. Cleanup with rm -f is present. No temp file leakage detected.
Static false positives ignored (1)

These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.

Low
Hardcoded URLs in documentation and scripts
Multiple files contain hardcoded references to https://pexo.ai and related endpoints. These are the service's own URLs, documented as the default PEXO_BASE_URL. The base URL is configurable, allowing users to override the default.
URLs point to the service's own documented domain. PEXO_BASE_URL is configurable, mitigating lock-in risk.
Audited by: claude

Apr 14, 2026, 08:45 AM

This skill is an API client for the Pexo AI video platform. Static analysis detected 534 potential security patterns across 13 files, but the majority are false positives reflecting standard CLI tool behavior. The skill uses shell scripts to make authenticated HTTP requests, read local configuration, and manage temporary files. Detected patterns (external commands, network calls, filesystem access, environment variable reads) are all expected for an API client skill. Weak cryptographic algorithms (MD5/SHA1) are used for file checksums, which is low-risk in this context. No credential exfiltration, unauthorized network access, or malicious patterns were found after manual evaluation.

13
Files scanned
2,110
Lines analyzed
10
Review items
1
False positives ignored

Confirmed security concerns (1)

High
Weak Cryptographic Algorithm Usage
Multiple scripts use MD5 or SHA1 for file checksums and hashing. These algorithms are cryptographically weak and should not be used for security-critical operations. In this context, they are used for file integrity checks and deduplication, not security.
Pattern confirmed: md5sum/sha1sum commands used in scripts for file hashing. Not security-critical in this context, but flagged as weak crypto.
Capability review items (5)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

High
API Key Access from Local Configuration
The skill reads PEXO_API_KEY from a local config file (~/.pexo/config) and uses it in HTTP Authorization headers. This is expected behavior for an API client skill, but grants the skill access to the user's API credentials. If the skill were modified maliciously, it could exfiltrate the key.
Pattern confirmed: PEXO_API_KEY is sourced from config and used in Authorization header. This is legitimate API client behavior, but flagged as high-risk because the skill has access to credentials.
Medium
External Shell Command Execution
The skill uses extensive shell command substitution ($(command)) and curl invocations to interact with the Pexo API. This is legitimate CLI tooling for an API client, but the pattern triggers static analysis due to the general risk of command injection if user input were passed unsafely to shell commands.
Pattern confirmed: shell commands are used for legitimate API calls and file operations. No user-input injection vectors found in the script source, but SKILL.md instructs the AI agent to execute commands which requires trust in the AI's behavior.
Medium
Network Access to External API
The skill makes HTTP requests to pexo.ai and related URLs. This is expected for an API client, but the network access could be misused if the skill were modified to send data to unauthorized endpoints.
Pattern confirmed: curl commands target pexo.ai API endpoints. All URLs point to the official Pexo service, which is consistent with the skill's stated purpose.
Medium
Hidden File Access in Home Directory
The skill reads from ~/.pexo/config and writes to ~/.pexo/tmp. This is standard configuration and temporary file storage for a CLI tool, but access to hidden files in the home directory could be a vector for reading sensitive data if misused.
Pattern confirmed: config sourced from ~/.pexo/config and temp directory at ~/.pexo/tmp. These are the skill's own files, not unrelated hidden files.
Low
System Information Commands in Diagnostic Scripts
The doctor and troubleshooting scripts use commands like uname, df, and free to diagnose system configuration issues. These are legitimate diagnostic tools for a setup wizard.
Pattern confirmed: system diagnostic commands used in doctor/troubleshooting scripts for legitimate setup assistance purposes.
Static false positives ignored (1)

These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.

Low
Hardcoded URLs in Documentation
The SKILL.md and reference files contain hardcoded URLs to pexo.ai documentation and API endpoints. These are legitimate service URLs, not malicious endpoints.
Pattern confirmed: all URLs point to pexo.ai or pexo-skills GitHub repository. These are legitimate documentation and API references.
Audited by: claude

Apr 13, 2026, 08:52 AM

This skill is a legitimate AI video production CLI tool that interacts with the Pexo API. The static analyzer flagged 534 patterns across 13 files, but most are false positives from standard shell scripting conventions. All network requests target the declared Pexo API endpoint (pexo.ai). Shell commands use safe argument construction via jq --arg (no injection vectors). The credential handling follows standard API key patterns. No malicious behavior, data exfiltration, or unauthorized access was found. Users should be aware the skill requires network access to an external API, stores API keys in a local config file, and executes shell scripts.

13
Files scanned
2,110
Lines analyzed
7
Review items
1
False positives ignored
Capability review items (3)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Medium
External API dependency with credential handling
The skill makes network requests to an external API (pexo.ai) using a bearer token API key. The API key is stored in a plaintext config file at ~/.pexo/config. This is a standard pattern but users should understand their credentials are transmitted to a third-party service.
Medium
Shell script execution with external process invocations
The skill contains 9 shell scripts that invoke external commands (curl, jq, file, stat, mktemp, date, sed, awk, tr). These are standard Unix utilities used for HTTP requests, JSON processing, and file handling. Arguments are constructed safely using jq --arg, preventing shell injection.
Medium
Configuration file stored in home directory
The skill reads and sources a configuration file at ~/.pexo/config which contains the API key and base URL. This is documented to the user. The file is sourced (not just read), which means it executes any content in the file. Users should ensure this file only contains the expected environment variable assignments.
Static false positives ignored (1)

These static matches were dismissed by semantic review or matched schema-only tokens, so they are shown for transparency but do not drive the quality score.

Low
Static analyzer flagged patterns are false positives
The static analyzer flagged 534 patterns including external_commands (349), network (27), filesystem (79), and env_access (25). All flagged patterns are standard shell scripting conventions: command substitution $(...), curl HTTP requests to declared endpoints, temp file creation with mktemp, and environment variable reads for configuration. No actual security vulnerabilities were confirmed.
Audited by: claude

Apr 12, 2026, 08:30 AM

Static analysis flagged 534 patterns across 13 files, but evaluation confirms these are FALSE POSITIVES. The skill is a legitimate CLI tool for the Pexo AI video platform. Shell command substitution patterns are standard bash scripting for API calls to pexo.ai. Environment variable access (PEXO_API_KEY, PEXO_BASE_URL) is documented authentication. Filesystem access targets the skill's own config directory (~/.pexo/). Network calls go exclusively to the official Pexo API. No malicious patterns, credential exfiltration, or command injection vectors detected.

13
Files scanned
2,110
Lines analyzed
5
Review items
0
False positives ignored

Confirmed security concerns (1)

Low
API Key Required in Configuration
The skill requires PEXO_API_KEY to be stored in ~/.pexo/config file. This is documented and expected for API authentication, but users should ensure proper file permissions on the config file.
Clear documentation of required API key storage - standard practice but worth noting for security awareness.
Capability review items (1)

These are real local capabilities that may be expected for this skill, so they require review but are not counted as confirmed malicious behavior.

Low
External API Dependencies
All functionality depends on external Pexo API endpoints (pexo.ai). Network calls use hardcoded URLs which is appropriate for a dedicated API client but means the skill cannot function offline.
All network calls target pexo.ai domain - expected behavior for an API client skill.
Audited by: claude