Back to skill

Security audit

Deploy

Security checks for vulnerabilities and agentic risk

Overview

This deployment skill is purpose-aligned, but it can automatically publish code, change production databases, and execute repository-controlled deployment instructions without clear approval gates.

Review this skill carefully before installing. It is not clearly malicious, but it should only be used in repositories and cloud environments where you are comfortable with an agent committing all changes, pushing to remotes, running migrations, and deploying to production. Require manual approval for exact commands, target branch, target environment, migration effects, and any repository-provided deployment scripts.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:68
Finding
Untrusted Project Plans Can Direct Arbitrary Deployment Command Execution<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:68` **Vulnerability Type**: Trusting repository-controlled deployment instructions without validation **Risk Level**: High ### Vulnerable Code Snippet ```markdown **Plan-driven deploy:** If the active plan contains deploy phases or tasks (e.g. "deploy Python backend to VPS", "run deploy.sh", "set up Docker on server"), treat those as **primary deploy instructions**. The plan knows the project-specific deploy targets that the generic stack YAML may not cover. Execute plan deploy tasks in addition to (or instead of) the standard platform deploy below. ``` ### Technical Analysis The skill instructs the agent to treat project-controlled plan documents as primary deployment instructions and execute their tasks. The project repository is an untrusted input boundary: an attacker who can contribute repository content can place malicious commands or references to malicious scripts in `docs/plan/*/plan.md`. No command allowlist, script inspection requirement, trust validation, or explicit user-confirmation gate is imposed before plan-derived instructions are executed. Because the skill permits Bash and deployment tools, a crafted plan could direct the agent to run a repository script, access a remote server, alter deployment infrastructure, or invoke commands unrelated to the legitimate deployment. ### Attack Path 1. An attacker adds or modifies an active `docs/plan/*/plan.md`. 2. The plan presents a malicious command or script as a required deployment task, such as running a modified `deploy.sh`. 3. The skill loads the plan and treats its tasks as primary deployment instructions. 4. The agent executes the referenced command or script through Bash. 5. The command runs with the permissions and environment of the agent process, potentially including authenticated repository and cloud CLI sessions. ### Impact Assessment Successful exploitation could execute commands with the local privileges of the ag ...[truncated 605 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Treat all repository documentation and deployment plans as untrusted input. 2. Parse plan files as descriptive context rather than executable authority. 3. Restrict plan-derived actions to a documented allowlist of deployment operations. 4. Require explicit user confirmation before executing any command originating from a plan file. 5. Display the exact command, target host, affected environment, and expected side effects before execution. 6. Inspect referenced scripts in full and reject scripts containing unrelated network access, credential access, destructive commands, privilege escalation, or persistence behavior. 7. Run approved scripts in a sandbox with minimal filesystem access, restricted network access, and narrowly scoped credentials. 8. Prefer known deployment commands derived from reviewed stack configuration over free-form commands embedded in project documents. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:52
Finding
Supabase CLI Is Executed Through Unpinned npx Package Resolution<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:52` **Vulnerability Type**: Unpinned third-party package retrieval and execution **Risk Level**: High ### Vulnerable Code Snippet ```bash npx supabase --version 2>/dev/null && echo "SUPABASE_CLI=yes" || echo "SUPABASE_CLI=no" ``` ### Technical Analysis The CLI detection command invokes `npx supabase` without requiring a locally installed, lockfile-controlled package and without using an exact reviewed version. If the package is unavailable locally, `npx` may retrieve executable package content from the configured package registry. Consequently, a command intended only to detect a CLI can cause third-party code to be downloaded and executed. The effective code can change after the skill has been reviewed because no version or integrity value is specified. ### Attack Path 1. The Supabase CLI is not installed in the local project or package cache. 2. The skill runs `npx supabase --version` as a detection step. 3. `npx` resolves and downloads the package from the configured registry. 4. Package installation behavior or CLI entry-point code executes under the agent account. 5. A compromised registry package, compromised release, or unsafe registry configuration can execute malicious code and access resources available to the process. ### Impact Assessment The downloaded package executes with the privileges of the agent process. It may therefore access project files, readable environment variables, local tokens, and authenticated deployment configuration. The affected cloud scope depends on credentials available in the environment; no privilege beyond those existing permissions is inherently obtained. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Detect globally installed CLIs without invoking a package installer, for example with `command -v supabase`. 2. For a project-local CLI, require a dependency installed from the reviewed lockfile. 3. Invoke the local package with `npx --no-install supabase --version` so detection fails rather than downloading code. 4. If installation is necessary, pin an exact reviewed version and require explicit user approval. 5. Enforce lockfile integrity and use a trusted, explicitly configured registry. 6. Run package installation with minimal credentials and outside environments containing production secrets. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:154
Finding
Drizzle Migration Commands Execute an Unpinned Package Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:154-155` **Vulnerability Type**: Unpinned third-party package execution with database access **Risk Level**: High ### Vulnerable Code Snippet ```bash npx drizzle-kit push # push schema to database npx drizzle-kit generate # generate migration files (if needed) ``` ### Technical Analysis The skill executes `drizzle-kit` through `npx` without requiring a lockfile-installed binary or specifying an exact reviewed version. If the package is not installed locally, package manager resolution can download and execute current registry content. This case has additional sensitivity because `drizzle-kit push` is expected to access and modify a configured database. A compromised package would execute in a context likely to contain database configuration or credentials and could perform operations beyond the intended schema migration. ### Attack Path 1. A project contains `drizzle.config.ts`, causing the Drizzle deployment path to be selected. 2. `drizzle-kit` is absent from trusted local dependencies or is resolved using an unsafe package source. 3. The skill invokes `npx drizzle-kit push`. 4. `npx` retrieves and executes package code from the configured registry. 5. Malicious package code reads accessible configuration or credentials and may alter the target database, local files, or other resources available to the agent. ### Impact Assessment Potential impact includes arbitrary code execution under the agent account, exposure of database connection information readable by the process, unauthorized database changes, and access to project files. Database impact is limited to the permissions granted by the configured database credential, but those permissions may be sufficient for production schema or data modification. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require `drizzle-kit` to be declared in the project dependencies and installed from the committed lockfile. 2. Invoke it with `npx --no-install drizzle-kit` or the package manager's equivalent local-only execution mode. 3. Verify the installed package version against the reviewed dependency manifest before migration. 4. Never resolve a new package version during a production deployment. 5. Use a narrowly scoped migration credential rather than a broad database administrator credential. 6. Generate and review migration output before applying changes to production. 7. Require explicit approval before executing schema-changing commands. 8. Back up the database and use a transaction or tested rollback procedure where supported. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:123
Finding
Blanket Git Staging Can Commit and Push Sensitive Files<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:123-127` **Vulnerability Type**: Unsafe automatic repository staging and publication **Risk Level**: High ### Vulnerable Code Snippet ```bash If dirty, commit remaining changes: ```bash git add -A git commit -m "chore: pre-deploy cleanup" ``` ``` ### Technical Analysis `git add -A` stages every modified, deleted, and untracked file visible to Git. The skill then commits those changes and subsequently instructs the agent to push the repository. There is no mandatory review of the staged diff, secret scan, allowlist, or user-confirmation gate between staging and publication. Although the skill separately states that secrets must not be committed, that policy does not technically prevent `.env` files, credentials, private keys, generated artifacts, or unrelated work from being included when ignore rules are absent or incomplete. ### Attack Path 1. A sensitive or unrelated file exists in the working tree and is not excluded by `.gitignore`. 2. The repository is dirty when deployment begins. 3. The skill runs `git add -A`, staging the file along with legitimate changes. 4. The skill creates the automatic cleanup commit. 5. The later `git push origin main` operation publishes the commit to the configured remote. 6. Users or systems with access to the remote can retrieve the committed content; removal from the latest revision does not automatically remove it from Git history. ### Impact Assessment Potential exposure includes API keys, environment files, private keys, deployment configuration, proprietary source files, personal data, and unrelated development changes. The publication scope is the configured Git remote and all users or automation with access to it. If the repository is made public or connected to external automation, exposure may extend beyond the intended team. The command can also unintentionally commit deletions or incomplete changes, potentially causing deployment failures or ...[truncated 41 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not use `git add -A` automatically during deployment. 2. Display `git status --short` and require the user to review the changed-file list. 3. Stage only an explicit allowlist of deployment-related files. 4. Run a secret scanner over both the working tree and staged content before committing. 5. Inspect the exact staged patch with `git diff --cached`. 6. Block known sensitive filename patterns, including `.env*`, private keys, credential files, token files, and cloud configuration containing secrets. 7. Require explicit user confirmation before both the commit and push operations. 8. If a secret is detected, abort the deployment and instruct the user to rotate it if it may already have entered Git history. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (16)

Credential Access

High
Category
Privilege Escalation
Content
1. **Use installed CLIs** — detect `vercel`, `wrangler`, `supabase`, `fly`, `sst` before falling back to `npx`.
2. **Auto-deploy aware** — if platform auto-deploys on push, just push. Don't run manual deploy commands unnecessarily.
3. **NEVER commit secrets** — no .env files with real values, no API keys in code.
4. **Preview before production** — deploy preview first, verify, then promote to prod.
5. **Check build locally first** — `pnpm build` / `uv build` (or equivalent) before deploying.
6. **Check production logs** — always tail logs after deploy, catch runtime errors before declaring success.
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The activation guidance includes broad phrases like 'deploy it' and 'push to production', which can match ordinary conversational requests and trigger a powerful deployment skill. Because this skill performs git pushes, database changes, repo creation, and production rollout, over-broad triggering raises the risk of accidental high-impact execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
83% confidence
Finding
The skill invokes `npx supabase --version`, which can fetch and execute a package version not explicitly pinned. In a deployment skill with Bash access, unpinned `npx` usage increases supply-chain risk because a compromised or unexpected upstream release could be executed on the operator's machine.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
If `$ARGUMENTS` specifies a platform, use that instead of auto-detection or YAML.

**Auto-deploy platforms** (from YAML `deploy` field or fallback):
- `vercel` / `cloudflare_pages` — auto-deploy on push. Push to GitHub is sufficient if project is already linked. Only run manual deploy for initial setup.
- `cloudflare_workers` — `wrangler deploy` needed (no git-based auto-deploy for Workers).
- `fly.io` — `fly deploy` needed.
Confidence
85% confidence
Finding
The skill autonomously decides deployment behavior from YAML or fallback logic, including whether a push is sufficient or a platform-specific deploy is needed. In a deployment context, automated decision-making without an approval gate can send code live based on inferred configuration rather than explicit user intent.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
If `$ARGUMENTS` specifies a platform, use that instead of auto-detection or YAML.

**Auto-deploy platforms** (from YAML `deploy` field or fallback):
- `vercel` / `cloudflare_pages` — auto-deploy on push. Push to GitHub is sufficient if project is already linked. Only run manual deploy for initial setup.
- `cloudflare_workers` — `wrangler deploy` needed (no git-based auto-deploy for Workers).
- `fly.io` — `fly deploy` needed.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
If `$ARGUMENTS` specifies a platform, use that instead of auto-detection or YAML.

**Auto-deploy platforms** (from YAML `deploy` field or fallback):
- `vercel` / `cloudflare_pages` — auto-deploy on push. Push to GitHub is sufficient if project is already linked. Only run manual deploy for initial setup.
- `cloudflare_workers` — `wrangler deploy` needed (no git-based auto-deploy for Workers).
- `fly.io` — `fly deploy` needed.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
If `$ARGUMENTS` specifies a platform, use that instead of auto-detection or YAML.

**Auto-deploy platforms** (from YAML `deploy` field or fallback):
- `vercel` / `cloudflare_pages` — auto-deploy on push. Push to GitHub is sufficient if project is already linked. Only run manual deploy for initial setup.
- `cloudflare_workers` — `wrangler deploy` needed (no git-based auto-deploy for Workers).
- `fly.io` — `fly deploy` needed.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
If `$ARGUMENTS` specifies a platform, use that instead of auto-detection or YAML.

**Auto-deploy platforms** (from YAML `deploy` field or fallback):
- `vercel` / `cloudflare_pages` — auto-deploy on push. Push to GitHub is sufficient if project is already linked. Only run manual deploy for initial setup.
- `cloudflare_workers` — `wrangler deploy` needed (no git-based auto-deploy for Workers).
- `fly.io` — `fly deploy` needed.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill instructs automatic `git add`, `git commit`, `git push`, and even `gh repo create --push` without an explicit approval checkpoint. In context, that can publish unreviewed code, exfiltrate proprietary work to a new remote, or alter repository history based on an ambiguous deployment request.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
gh repo create {project-name} --private --source=. --push
```

**For platforms with auto-deploy (Vercel, CF Pages):** pushing to main triggers deployment automatically. Skip manual deploy commands if project is already linked.

### Step 2. Database Setup
Confidence
88% confidence
Finding
The instruction that pushing to main is sufficient for auto-deploy platforms directly links a git push to production release. In context, because the skill also performs automated pushes, this creates a clear path to unintended live deployment without a separate confirmation step.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The database section directs schema push and migration commands (`supabase db push`, `drizzle-kit push`, `wrangler d1 migrations apply`) without requiring a warning or confirmation. These operations can irreversibly alter production databases, cause data loss, or apply incompatible schema changes if auto-executed.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
`npx drizzle-kit push` executes an unpinned package during a database deployment step. Because this runs in a privileged operational context and can alter schema state, an unexpected or malicious package release could both execute arbitrary code and change production data structures.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
`npx drizzle-kit generate` has the same unpinned execution risk as other `npx` calls. In a deploy workflow, this can introduce supply-chain exposure at the exact moment code and schema artifacts are being prepared for production.

Intent-Code Divergence

Medium
Confidence
88% confidence
Finding
The skill says not to write real secrets to local `.env` files, but then recommends shell patterns such as `vercel env add NAME production <<< "value"` and `fly secrets set VARIABLE_NAME=value`. Supplying secrets directly on the command line or via shell redirection can expose them to shell history, process inspection, logs, transcripts, or agent output capture.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill includes direct production deployment commands such as `vercel --prod`, `wrangler deploy`, `fly deploy`, and `sst deploy --stage prod` without an explicit publish approval gate. This is dangerous because a simple invocation can immediately change live infrastructure or user-facing services.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Critical Rules

1. **Use installed CLIs** — detect `vercel`, `wrangler`, `supabase`, `fly`, `sst` before falling back to `npx`.
2. **Auto-deploy aware** — if platform auto-deploys on push, just push. Don't run manual deploy commands unnecessarily.
3. **NEVER commit secrets** — no .env files with real values, no API keys in code.
4. **Preview before production** — deploy preview first, verify, then promote to prod.
5. **Check build locally first** — `pnpm build` / `uv build` (or equivalent) before deploying.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.