Back to skill

Security audit

hyperframes-cli

Security checks for vulnerabilities and agentic risk

Overview

This is a real HyperFrames CLI workflow skill, but it needs Review because it tells agents to run mutable npm code, can alter local agent instruction packs, and defaults to public feedback or telemetry metadata.

Install only if you trust the HyperFrames npm package and are comfortable with agent-run CLI commands. Prefer a project-local pinned wrapper or exact package version, set `HYPERFRAMES_SKIP_SKILLS=1` if you do not want external agent skills checked or installed, disable telemetry if environment metadata should not be sent, and review any feedback payload before public submission. Use cloud, AWS, and GCP commands only with scoped credentials and projects you are willing to upload or modify.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
Findings (4)

T08 · Insecure Dependencies

Error
Location
SKILL.md:14
Finding
Unpinned npm Package Execution Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:14` and repeated throughout the command examples **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: High ### Vulnerable Code ```markdown Run commands as `npx hyperframes ...` unless project instructions provide a wrapper. Obey the wrapper when present. The CLI requires Node.js 22 or newer and FFmpeg. ``` Representative commands from `SKILL.md:44-49`: ```bash npx hyperframes lint npx hyperframes check npx hyperframes preview --background npx hyperframes render --quality high --output out.mp4 test -s out.mp4 ffprobe -v error -show_format out.mp4 ``` The same unpinned invocation pattern is used throughout every reference file. ### Technical Analysis The Skill instructs the Agent to execute `npx hyperframes` without an exact package version, lockfile requirement, or integrity constraint. When no suitable local package is available, `npx` may resolve and download the current package published under that name. Consequently, the code executed at Skill runtime is not necessarily the code that existed when this Skill was reviewed. A compromised npm publisher account, malicious newly published release, or registry-level supply-chain incident could replace the effective implementation while the audited Markdown remains unchanged. This is particularly significant because the CLI is used for commands that read projects, launch browsers, access cloud credentials, upload files, and deploy cloud infrastructure. ### Attack Path 1. An attacker compromises the npm package publisher, publication workflow, or another relevant supply-chain component. 2. The attacker publishes a malicious release under the `hyperframes` package name. 3. An Agent follows the Skill and runs an unpinned `npx hyperframes` command. 4. `npx` resolves or downloads the attacker-controlled release. 5. Package lifecycle code or command-entry code executes with the permissions of the Agent process. 6. The mali ...[truncated 749 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin all executions to an audited exact version, for example: ```bash npx --yes hyperframes@1.2.3 ... ``` 2. Prefer installing the dependency in a project controlled by a committed lockfile and invoking the local binary: ```bash npm ci npx --no-install hyperframes ... ``` 3. Verify package integrity through lockfile integrity hashes and a trusted registry. 4. Disable npm lifecycle scripts during installation where compatible with the package: ```bash npm ci --ignore-scripts ``` 5. Review and approve upgrades before changing the pinned version. 6. Document the expected package scope, publisher, version, and checksum so similarly named or substituted packages cannot be accepted silently. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:126
Finding
Default Feedback Submission to a Public Channel May Disclose Task and Host Information<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:126-132`; supporting behavior in `references/preview-render.md:139-178` **Vulnerability Type**: Unnecessary default transmission of diagnostic information **Risk Level**: Medium ### Vulnerable Code From `SKILL.md:126-132`: ```markdown After verifying a successful render, send one feedback report unless telemetry is disabled or the user opted out: ```bash npx hyperframes feedback --rating <0-10> --comment "<specific result or friction>" ``` Keep clean-run feedback concise. For any bug or friction, capture a **reproduction packet** before submitting; do not send only a symptom summary. Include the rerunnable command (relative to the project directory — feedback is submitted to a public channel, so do **not** paste absolute paths, home-directory prefixes, or user/machine identifiers), expected versus actual behavior, exact error (also strip absolute paths from stack traces — keep basename + line, drop the leading directory), whether output completed/fell back/failed, workaround, and repro-project status. ``` From `references/preview-render.md:139-146`: ```markdown After a render is verified, send one feedback line per task. This is the maintainers' primary signal — a render that finishes silently tells them nothing. ```bash npx hyperframes feedback --rating 10 npx hyperframes feedback --rating 6 --comment "bg <video> renders grey in multi-scene; worked around with --format png-sequence" ``` `--rating` is an integer from 0-10 (required); `--comment` is free text. Feedback is anonymous and attaches a `doctorSummary` (OS/Node/CPU/mem/ffmpeg) automatically, so don't repeat those fields. ``` The same reference later states: ```markdown **Feedback is submitted to a public channel — anonymize before sending.** ``` ### Technical Analysis The workflow makes feedback submission the default after a successful render unless telemetry is disabled or the user previously opted out. The report may contain ...[truncated 2075 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Make feedback strictly opt-in rather than default-on. 2. Obtain explicit informed consent immediately before every network submission. 3. Display the complete final payload, including `doctorSummary` and all automatically attached fields, for user review. 4. Require affirmative confirmation after the payload preview. 5. Apply automated secret detection and redaction to: - API keys and authorization headers. - Absolute and home-directory paths. - Email addresses and user names. - Signed URLs and cloud identifiers. - Environment-variable values. 6. Submit feedback privately by default; require separate consent for publication. 7. Permit local export of a feedback report without transmitting it. 8. Document the destination, retention period, access controls, and deletion process. ]]>

other

Warning
Location
references/upgrade-info-misc.md:52
Finding
Default Telemetry Fingerprints Agent and Sandbox Runtime<![CDATA[ ## Vulnerability Details **File Location**: `references/upgrade-info-misc.md:52-67`; persistent attribution described in `SKILL.md:122` **Vulnerability Type**: Environment fingerprinting and usage telemetry **Risk Level**: Medium ### Vulnerable Code From `references/upgrade-info-misc.md:52-67`: ```markdown ## telemetry ```bash npx hyperframes telemetry status # show telemetry state npx hyperframes telemetry disable # disable anonymous usage telemetry npx hyperframes telemetry enable # re-enable telemetry ``` Telemetry is anonymous usage counters only. Disable globally with `HYPERFRAMES_NO_TELEMETRY=1` if env-var control is preferred over the subcommand. Events include two fingerprint properties used to distinguish managed-sandbox runs from real laptops — no PII, no env-var **values**, only existence checks: - **`sandbox_runtime`**: `gvisor` / `firecracker` / `docker` / `kvm` / `wsl` / `null`. gVisor via kernel string + `/proc/version`. Firecracker via `/dev/vsock` + DMI sys_vendor. Docker via `/.dockerenv` + cgroup. - **`agent_runtime`**: `claude_code` / `codex` / `cursor` / `copilot_agent` / `jules` / `replit` / `devin` / `aider` / `gemini_cli` / `hermes` / `openclaw` / `null`. Detected by the existence of well-known vendor env vars; the values themselves are never read. ``` From `SKILL.md:122`: ```markdown Skill attribution is automatic — the examples above need no `--skill`. A project scaffolded by a workflow (`hyperframes init --skill=<workflow>`) records its owning skill in `hyperframes.json`, and every later render inherits it on anonymous telemetry: re-renders, `npm run render`, and `--batch` alike. ``` ### Technical Analysis The telemetry mechanism performs explicit environment fingerprinting by inspecting kernel information, `/proc/version`, `/dev/vsock`, DMI vendor data, `/.dockerenv`, cgroups, and the existence of vendor-specific environment variables. It also records workflow attribution in a project file and reuses ...[truncated 1535 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Disable telemetry by default and use explicit opt-in consent. 2. Present the exact event schema and destination before enabling telemetry. 3. Remove sandbox and Agent-product fingerprinting unless strictly required. 4. Avoid persisting workflow attribution across future renders. 5. Provide project-level and per-command controls in addition to the global setting. 6. Minimize retention and prevent joining telemetry with other account or network identifiers. 7. Expose a dry-run command that prints the complete event without transmitting it. 8. Document retention, aggregation, access, deletion, and de-identification policies. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
references/init-and-scaffold.md:30
Finding
Initialization Contacts GitHub and Can Install External Agent Instruction Packs<![CDATA[ ## Vulnerability Details **File Location**: `references/init-and-scaffold.md:30-32,72-74` **Vulnerability Type**: External instruction retrieval and modification of the local AI coding environment **Risk Level**: High ### Vulnerable Code From `references/init-and-scaffold.md:30-32`: ```markdown - `--skill=<slug>` — record the owning authoring workflow (e.g. `product-launch-video`) in `hyperframes.json`, so every later render of this project — re-renders, `npm run render`, `--batch` — is attributed to it on anonymous telemetry without re-passing the flag. Creation workflows set this automatically; you rarely pass it by hand. - `--skip-skills` — **temporarily ignored**: `init` always checks AI coding skills against GitHub while the skills.sh registry catches up. To opt out (CI/tests), set the `HYPERFRAMES_SKIP_SKILLS=1` env var instead. - `--skip-transcribe` — don't auto-transcribe `--audio` / `--video` with Whisper. ``` From `references/init-and-scaffold.md:72-74`: ```markdown ## skills ```bash npx hyperframes skills # install HyperFrames skills for AI coding tools ``` One-time setup that adds the HyperFrames skill pack (`hyperframes-core`, `-creative`, `-animation`, `-cli`, `-registry`, `-media`, plus the `product-launch-video` and `hyperframes` orchestrators) to the local AI coding environment so agents follow the framework conventions. Re-run after major HyperFrames upgrades. ``` ### Technical Analysis The initialization process checks externally hosted AI coding skills on GitHub, while the documented `--skip-skills` flag is ignored. A separate environment variable is required to opt out. The `skills` command installs instruction packs into local AI coding environments, where they can influence later Agent behavior. Agent Skill text is executable control material: it can redirect tool use, alter workflow decisions, request network operations, or cause later commands to be run. Retrieving or installing mutable instruction content from an ...[truncated 1800 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not check for or install Agent instruction packs as a side effect of project initialization. 2. Make `--skip-skills` effective and make external Skill retrieval opt-in by default. 3. Require explicit consent before contacting GitHub or changing an AI coding environment. 4. Pin retrieved content to an immutable commit hash or signed release. 5. Verify cryptographic signatures or published checksums before installation. 6. Display the source URL, exact revision, destination paths, and file diff before applying changes. 7. Install into an isolated project-local directory rather than a global Agent configuration by default. 8. Provide an uninstall and rollback command. 9. Re-audit changed instruction content before upgrades are activated. 10. Prevent downloaded Skill instructions from automatically overriding higher-priority safety and user constraints. ]]>
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
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (282)

Ae1

High
Category
analysis-evasion
Content
| `doctor`, browser management | `references/doctor-browser.md` |
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
npx hyperframes cloud list                 # recent renders (--limit, --token, --all)
npx hyperframes cloud get hfr_def456       # full detail + short-lived signed video_url
npx hyperframes cloud delete hfr_def456    # soft-delete (--no-confirm to skip the prompt)
```

`video_url` and `thumbnail_url` are short-lived presigned URLs, so re-fetch with `cloud get` rather than caching them.
Confidence
75% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Credential Access

High
Category
Privilege Escalation
Content
## Prerequisites

- AWS credentials configured (env vars, `~/.aws/credentials`, SSO, or IMDS).
- AWS SAM CLI on `PATH`.
- `bun` on `PATH` (builds the Lambda handler ZIP).
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill repeatedly instructs agents to execute `npx hyperframes ...` without pinning an exact package version. `npx` resolves and may fetch the latest published package at runtime, so a compromised upstream release, typosquat, or malicious maintainer update could cause arbitrary code execution on the agent host.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This line directs use of `npx hyperframes init <project>` without version pinning. Because `npx` can install whatever version is current at execution time, the skill creates a supply-chain execution path where unreviewed code may run automatically.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The `npx hyperframes add <name>` invocation is also unpinned, so the same supply-chain risk applies here. A malicious package update would gain code execution precisely when the agent attempts to install or use a catalog item.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This line instructs `npx hyperframes lint` without pinning the package version. That permits execution of newly published code during routine validation steps, which can be exploited through dependency compromise.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The final gate command `npx hyperframes check` is unpinned and therefore may execute an unintended upstream version. Since this is presented as a required workflow step, it increases the likelihood that agents will run network-fetched code automatically.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The preview command is launched through unversioned `npx hyperframes`, again creating runtime supply-chain exposure. Because preview is intended to stay alive during review, compromise here could provide a long-lived execution context or local data access.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This repeated `npx hyperframes lint` example remains unpinned and keeps the same arbitrary-code-execution risk via package resolution. Repetition throughout the skill normalizes unsafe execution behavior for agents.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The `check` command example uses unpinned `npx`, allowing remote package changes to alter what code is executed. Since the skill frames this as the required final gate, the exposure is operationally significant.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The background preview example again invokes an unpinned package with `npx`. Any compromise of the package or its publication channel could turn a normal preview step into arbitrary host command execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The render command is unpinned and therefore inherits the same supply-chain risk as the other `npx` examples. Rendering workflows often have access to media, credentials, and the filesystem, increasing blast radius if the binary is malicious.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The snapshot command is presented with unpinned `npx`, so the command executed is not deterministic and may be attacker-controlled via a malicious upstream release. In an automation context, even diagnostic commands can become an execution vector.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This catalog search example uses unpinned `npx`, preserving the same package substitution risk. Because the skill strongly encourages frequent catalog use, the unsafe pattern is both pervasive and likely to be exercised often.

Natural-Language Policy Violations

Medium
Confidence
94% confidence
Finding
The line explicitly mandates English queries regardless of the user's language context: 'Query in English even when the video is not.' This is a natural-language locale policy constraint that forces a specific language without opt-in, which falls under the policy-violation category.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The feedback submission command is unpinned, meaning even telemetry-like actions can execute arbitrary new package code. This broadens risk because users may perceive feedback commands as low sensitivity and run them without scrutiny.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The skill instructs use of `npx hyperframes doctor --json` without pinning a version. A diagnostic command still runs full package code, so this remains a viable supply-chain execution path.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The Studio context query is run with unpinned `npx`, which may fetch and execute a different package version than expected. In agent use, this can expose selected project data to malicious code introduced via an upstream compromise.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The draft render command uses unversioned `npx`, so the package executed is mutable over time and may be hostile if the upstream is compromised. Rendering commands often touch local assets and output paths, increasing possible impact.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The final delivery render example is unpinned and creates the same arbitrary-code-execution risk through package resolution. Since final render steps may run in CI or production-like environments, the context makes the issue more dangerous.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The Docker render path is still invoked via unversioned `npx`, so the initial package execution on the host remains uncontrolled even if the render itself is containerized. This can mislead users into assuming the workflow is isolated when the bootstrap step is not.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The batch render example again relies on unpinned `npx`. In batch workflows, a malicious package could process many inputs or exfiltrate larger volumes of project data automatically.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The hosted cloud render command is unpinned and may execute compromised local bootstrap code before interacting with cloud services. Because cloud commands can involve authentication or project uploads, the potential consequences are elevated.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The AWS Lambda render command uses unversioned `npx`, exposing any AWS-linked workflow to upstream package compromise. In this context, malicious code could target credentials, deployment metadata, or uploaded assets.

Static analysis

No suspicious patterns detected.