MeowMusic YouTube MP3

• Outcome: Review
• Latest audit: Sep 15, 2026 · 1:44 AM UTC
• Version: 0.1.0

Overview

The skill is purpose-aligned for a MeowMusic YouTube fallback workflow, but it handles browser session cookies and admin tokens with insufficient safeguards.

Review this skill carefully before installing. Use it only with a dedicated low-privilege browser profile or account, a trusted server, HTTPS for any non-loopback endpoint, strong authentication on the cookie update API, restrictive file permissions, short retention for uploaded cookies, and pinned dependencies in an isolated environment.

A.I.G

Vulnerability Patterns

• Unauthorized Access and Privilege Escalation: Obtains permissions beyond the task's legitimate needs
• Insecure Dependencies: Introduces malicious components through unsafe dependency sources
• Insecure Skill Coding Practices: Finds exploitable flaws such as hardcoded secrets or command injection
• Skill Instruction Hijacking: Alters the agent's session goals or safety constraints when the skill loads
• Agent Memory Poisoning: Writes attacker-controlled rules into memory that affect later sessions

Findings (5)

T09 · Insecure Skill Coding Practices

Error

• Location: scripts/youtube_cookie_sync.py:31

Finding

Sensitive cookies and bearer token may be transmitted over plaintext HTTP to an unrestricted destination

Content

View full analysis

Vulnerability Details

File Location: scripts/youtube_cookie_sync.py, lines 31–44 and 55–56
Vulnerability Type: Sensitive data exposure through insufficient transport and destination validation
Risk Level: High

Vulnerable Code

python

def push_cookies(server, token, cookie_txt):
    with open(cookie_txt, "r", encoding="utf-8") as f:
        content = f.read()

    data = json.dumps({"content": content}).encode("utf-8")
    req = urllib.request.Request(
        server.rstrip("/") + "/api/admin/youtube-cookie/update",
        data=data,
        method="POST",
        headers={
            "Content-Type": "application/json",
            "Authorization": "Bearer " + token,
        },
    )
    with urllib.request.urlopen(req) as resp:
        print(resp.read().decode("utf-8", "replace"))

python

parser.add_argument("--server", default=os.environ.get("MEOW_SERVER_URL", "http://127.0.0.1:2233"))
parser.add_argument("--token", default=os.environ.get("MEOW_BEARER_TOKEN", ""))

Technical Analysis

The synchronization function reads the entire authenticated YouTube cookie file and sends it together with an administrative bearer token to a caller-configurable URL. The destination is not restricted by scheme, hostname, port, or an allowlist. Plaintext HTTP is accepted, and urllib.request.urlopen can follow redirects without enforcing that the redirected destination remains on the original trusted host.

Transferring YouTube cookies is part of the declared functionality, but sending complete session material to an unrestricted destination without mandatory transport protection exceeds safe minimum privilege. The default loopback HTTP endpoint is not exposed to network interception on a correctly configured local host, but the same insecure scheme remains accepted when the URL is changed to a remote server.

Attack Path

1. An attacker modifies MEOW_SERVER_URL, supplies ...[truncated 958 chars]

Remediation

View remediation

Remediation Suggestions

• Require HTTPS for every non-loopback destination.
• Permit plaintext HTTP only when the parsed destination is exactly a loopback address such as 127.0.0.1, ::1, or a deliberately validated local socket.
• Maintain an explicit allowlist of trusted server hostnames and ports.
• Reject URLs containing embedded credentials, fragments, unexpected paths, or unsupported schemes.
• Disable automatic redirects or validate every redirect target against the same scheme and host policy.
• Configure explicit connection and response timeouts.
• Display the normalized destination and request confirmation before exporting browser cookies when it is not a preconfigured trusted endpoint.
• Prefer a narrowly scoped, short-lived upload credential rather than a general administrative bearer token.
• Document certificate validation requirements and never provide an option that silently disables TLS verification.

T05 · Unauthorized Access and Privilege Escalation

Error

• Location: references/cookie-api-and-sync.md:20

Finding

Recommended administrative cookie update handler lacks authentication and authorization

Content

View full analysis

Vulnerability Details

File Location: references/cookie-api-and-sync.md, lines 20–48
Vulnerability Type: Missing access control on an administrative endpoint
Risk Level: High

Vulnerable Code

go

func HandleYouTubeCookieUpdate(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    var req struct { Content string `json:"content"` }
    body, _ := io.ReadAll(r.Body)
    if err := json.Unmarshal(body, &req); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    content := strings.TrimSpace(req.Content)
    if content == "" || !strings.Contains(content, "youtube.com") || !strings.Contains(content, "Netscape HTTP Cookie File") {
        http.Error(w, "Invalid YouTube cookie file", http.StatusBadRequest)
        return
    }

    path := youtubeCookiePath()
    tmpPath := path + ".tmp"
    os.WriteFile(tmpPath, []byte(content+"\n"), 0600)
    os.Rename(tmpPath, path)

    json.NewEncoder(w).Encode(map[string]interface{}{"status": "success"})
}

Technical Analysis

The documented handler is presented as the minimal implementation for the administrative cookie update endpoint, but it never verifies the Authorization header or checks whether the requester has administrative privileges. The client sends a bearer token, yet the recommended server implementation does not consume or validate it.

The /api/admin/ path name does not itself provide access control. Validation that the body resembles a Netscape cookie file only checks data shape; it does not establish requester identity or authority. If this pattern is implemented without protective middleware, any client able to reach the route can replace the server's YouTube cookie store.

Attack Path

1. The server implements the documented handler with ...[truncated 866 chars]

Remediation

View remediation

Remediation Suggestions

• Require authentication before reading or processing the request body.
• Validate a strong, randomly generated bearer credential and use a constant-time comparison where appropriate.
• Authorize the authenticated principal specifically for cookie administration; do not accept an unrelated general user token.
• Prefer a short-lived, narrowly scoped upload token.
• Place the endpoint behind TLS and, where possible, restrict it to a trusted network, VPN, or loopback interface.
• Ensure reverse-proxy and application middleware cannot accidentally bypass authentication for this route.
• Add rate limiting, failed-authentication monitoring, and audit logging for every update.
• Return 401 Unauthorized for missing or invalid credentials and 403 Forbidden for insufficient privileges.
• If browser-based clients can call the endpoint, also enforce an appropriate CSRF defense and restrictive CORS policy.

T09 · Insecure Skill Coding Practices

Warning

• Location: references/cookie-api-and-sync.md:30

Finding

Administrative cookie endpoint reads an unbounded request body into memory

Content

View full analysis

Vulnerability Details

File Location: references/cookie-api-and-sync.md, lines 30–36
Vulnerability Type: Unbounded request-body allocation and ignored input error
Risk Level: Medium

Vulnerable Code

go

var req struct { Content string `json:"content"` }
body, _ := io.ReadAll(r.Body)
if err := json.Unmarshal(body, &req); err != nil {
    http.Error(w, "Invalid JSON", http.StatusBadRequest)
    return
}

Technical Analysis

io.ReadAll(r.Body) buffers the complete request body without imposing a maximum size. The returned read error is discarded. A remote client can therefore cause the process to allocate memory proportional to the submitted body before JSON validation occurs.

Authentication alone does not fully remove the risk because stolen credentials, authorized-but-malicious clients, and requests processed before authentication can still exploit the unbounded allocation, depending on middleware ordering.

Attack Path

1. An attacker reaches the cookie update endpoint.
2. The attacker opens one or more POST requests with extremely large bodies or streams data slowly.
3. The handler repeatedly expands its in-memory buffer while io.ReadAll waits for end-of-body.
4. Memory, goroutines, and connections are exhausted.
5. The service becomes slow, unresponsive, or terminates because of resource exhaustion.

Impact Assessment

The primary impact is denial of service against the MeowMusic process. Depending on deployment limits, the effect may extend to other applications on the same host through memory pressure. This issue does not by itself provide code execution or access to arbitrary files.

Remediation

View remediation

Remediation Suggestions

• Apply http.MaxBytesReader before decoding the body, using a small limit appropriate for a browser cookie file.
• Decode JSON through json.Decoder after applying the limit rather than buffering the entire body.
• Reject trailing JSON values and malformed input.
• Check and handle all body-read or decoder errors.
• Configure server-level read-header, read-body, write, and idle timeouts.
• Add per-client rate limits and concurrency limits.
• Authenticate the requester before performing body-intensive processing.
• Return 413 Request Entity Too Large when the configured limit is exceeded.

T08 · Insecure Dependencies

Warning

• Location: scripts/install_server_env.sh:21

Finding

Bootstrap script installs unpinned third-party packages globally with elevated privileges

Content

View full analysis

Vulnerability Details

File Location: scripts/install_server_env.sh, lines 21–22
Vulnerability Type: Unpinned system-wide dependency installation
Risk Level: Medium

Vulnerable Code

bash

python3 -m pip install --break-system-packages -U yt-dlp || python3 -m pip install -U yt-dlp
npm install -g yt-dlp-ejs

Technical Analysis

The bootstrap script installs the newest available yt-dlp and yt-dlp-ejs releases without pinned versions, hashes, a lockfile, or an isolated environment. Because the rest of the script performs privileged package-manager operations, it is expected to be run as root. Package installation scripts and imported runtime code therefore receive broad host privileges.

--break-system-packages also allows pip to modify the system Python environment outside distribution package management, increasing the possibility of dependency conflicts and unintended changes to unrelated software. The audited package names correspond to the declared functionality, and there is no evidence that they are intentionally malicious; the risk arises from mutable, unverified supply-chain inputs and excessive installation scope.

Attack Path

1. An upstream registry account, package release, dependency, or distribution channel is compromised, or an incompatible release is published.
2. An administrator runs the bootstrap script with elevated privileges.
3. The package manager resolves the latest release rather than a previously reviewed version.
4. Package installation or runtime code executes with broad host access.
5. A malicious release can modify files, steal credentials, install persistence, or compromise the service; a defective release can destabilize the host.

Impact Assessment

A malicious upstream package can obtain the privileges of the administrator running the script, potentially including root access to the entire server. Even without malicious intent, unpinned upgrades can ...[truncated 190 chars]

Remediation

View remediation

Remediation Suggestions

• Pin exact, reviewed versions of all Python and npm packages.
• For Python, use an application-specific virtual environment and install from a requirements file with cryptographic hashes.
• For npm, install locally from a committed lockfile with integrity metadata instead of using npm install -g.
• Separate privileged operating-system package installation from unprivileged application dependency installation.
• Run downloader and transcoder processes under a dedicated, unprivileged service account.
• Review release provenance and use supported signature or attestation verification where available.
• Test updates in a staging environment and update pins deliberately.
• Avoid --break-system-packages; use distribution packages, pipx, or a virtual environment.

T09 · Insecure Skill Coding Practices

Note

• Location: scripts/youtube_cookie_sync.py:55

Finding

Administrative bearer token can be exposed through command-line arguments

Content

View full analysis

Vulnerability Details

File Location: scripts/youtube_cookie_sync.py, lines 55–61
Vulnerability Type: Secret exposure through process arguments and shell history
Risk Level: Low

Vulnerable Code

python

parser.add_argument("--server", default=os.environ.get("MEOW_SERVER_URL", "http://127.0.0.1:2233"))
parser.add_argument("--token", default=os.environ.get("MEOW_BEARER_TOKEN", ""))
args = parser.parse_args()

if not args.token:
    print("缺少 token：请传 --token 或设置环境变量 MEOW_BEARER_TOKEN", file=sys.stderr)
    sys.exit(1)

Technical Analysis

The script explicitly supports supplying the bearer credential with --token. Command-line arguments may be retained in shell history, process accounting, terminal transcripts, task definitions, support bundles, and automation logs. On systems where process arguments are visible to other users, the token can also be observed while the process is running.

Environment variables are offered as an alternative, but they can also leak through process inspection or deployment diagnostics. A protected credential file, inherited file descriptor, operating-system secret store, or interactive hidden prompt provides stronger handling.

Attack Path

1. An administrator invokes the script with --token <secret>.
2. The complete command is recorded in shell history, a scheduled-task definition, CI logs, process telemetry, or process listings.
3. A local user, log reader, support operator, or compromised monitoring component obtains the token.
4. The attacker reuses the token against the MeowMusic server.

Impact Assessment

The attacker obtains all privileges granted to the bearer token. At minimum, the documented workflow expects it to authorize replacement of the YouTube cookie file. If the same token is accepted by additional administrative APIs, compromise may affect a broader portion of the service.

Remediation

View remediation

Remediation Suggestions

• Remove or strongly discourage the --token command-line option.
• Read the token from a permission-restricted file, an operating-system credential manager, or an inherited file descriptor.
• For interactive use, obtain the token with getpass.getpass so it is not echoed.
• If environment variables remain supported, document their exposure risks and ensure deployment tooling does not log them.
• Use short-lived, narrowly scoped credentials so accidental disclosure has limited impact.
• Redact authorization values from application, proxy, CI, and debugging logs.
• Rotate any token that has previously been passed directly on a command line.

SkillSpector

Vulnerability Patterns

• Data Exfiltration: External Transmission, Env Variable Harvesting, File System Enumeration
• Privilege Escalation: Excessive Permissions, Sudo/Root Execution, Credential Access
• Behavioral AST: exec() Call, eval() Call, Dynamic Import
• YARA Signatures: Malware Match, Webshell Match, Cryptominer Match
• MCP Least Privilege: Underdeclared Capability, Wildcard Permission, Missing Permission Declaration

Findings (18)

YARA rule 'info_stealer': Information stealer patterns (credential harvesting, browser data theft) [malware]

High

• Category: YARA Match
• Confidence: 89% confidence

Finding

The YARA hit is not merely incidental wording: the skill explicitly promotes exporting cookies from a browser profile and syncing them to a server, which matches common information-stealer tradecraft. Although the apparent purpose is to make yt-dlp work against YouTube, the operational pattern is still dangerous because it normalizes credential extraction and remote transfer of session material.

Content

Scanner excerpt · SKILL.md (reported line 3)May include surrounding context.

md

mp3
description: "Package and reuse the MeowMusicServer-patched YouTube fallback workflow: Windows Chrome cookie export/sync to server, server-side yt-dlp/yt-dlp-ejs/ffmpeg setup, old-source-first with YouTube fallback, and MV-to-MP3 extraction/caching. Use when Claude needs to wire YouTube audio acquisition into MeowMusicServer or a similar music service, debug YouTube download failures, refresh cookies from a Windows Chrome profile, or implement a local-cache MP3 flow from YouTube videos."
---

# MeowMusic YouTube MP3

Use this skill to rebuild the currently working MeowMusicServer-patched solution into another repo/server without rediscovering the whole stack.

## Workflow decision tree

1. **Need cookie sync from Windows Chrome to server?**
   - Use `scripts/youtube_cookie_sync.py`.
   - If the user wants a double-click workflow on Windows, also use `scripts/windows/sync_cookie.bat` and `scripts/windows/open_youtube.bat`.
   - If you need API shape or server handler details, read `

Credential Access

High

• Category: Privilege Escalation
• Confidence: 98% confidence

Finding

The skill advertises a script that exports Chrome/Edge/Firefox cookies and pushes them to a server, which is a credential-access behavior because browser cookies often function as bearer tokens for authenticated sessions. Even without obvious exfiltration to a third-party host, packaging this as a reusable workflow meaningfully increases the chance of unsafe collection, transfer, storage, or misuse of authentication data.

Content

Scanner excerpt · SKILL.md (reported line 82)May include surrounding context.

md

## Files in this skill

- `scripts/install_server_env.sh` — server bootstrap for Node 22, yt-dlp, yt-dlp-ejs, ffmpeg.
- `scripts/youtube_cookie_sync.py` — export Chrome/Edge/Firefox cookies and push them to the server.
- `scripts/windows/sync_cookie.bat` — Windows double-click wrapper.
- `scripts/windows/open_youtube.bat` — helper to open YouTube in Chrome.
- `references/cookie-api-and-sync.md` — cookie API contract and usage notes.

Credential Access

High

• Category: Privilege Escalation
• Confidence: 93% confidence

Finding

Using yt-dlp --cookies-from-browser to extract cookies from Chrome, Edge, or Firefox is a credential-access pattern because it pulls session material from a user's browser profile and sends it to another system. In this skill's context, the behavior is framed as operational convenience for YouTube access, but it still enables transfer of bearer-like session tokens that could be abused for account access if mishandled.

Content

Scanner excerpt · references/cookie-api-and-sync.md (reported line 60)May include surrounding context.

md

Use `scripts/youtube_cookie_sync.py`.

Behavior:
1. Export cookies from Chrome/Edge/Firefox with `yt-dlp --cookies-from-browser`.
2. Tolerate a local validation failure if the cookie file was still successfully exported.
3. POST cookie text to the server API.

YARA rule 'info_stealer': Information stealer patterns (credential harvesting, browser data theft) [malware]

High

• Category: YARA Match
• Confidence: 88% confidence

Finding

The content matches information-stealer behavior because it describes harvesting cookies from installed browsers and posting them to a server. Although the likely goal is to support server-side media downloads rather than covert theft, the technique is intrinsically dangerous and closely overlaps with malware tradecraft, especially since it centralizes reusable session cookies on a remote host.

Content

Scanner excerpt · references/cookie-api-and-sync.md (reported line 60)May include surrounding context.

rror(w, "Invalid YouTube cookie file", http.StatusBadRequest) return }

text

path := youtubeCookiePath()
tmpPath := path + ".tmp"
os.WriteFile(tmpPath, []byte(content+"\n"), 0600)
os.Rename(tmpPath, path)

json.NewEncoder(w).Encode(map[string]interface{}{"status": "success"})

}

text

## Windows-side sync pattern

Use `scripts/youtube_cookie_sync.py`.

Behavior:
1. Export cookies from Chrome/Edge/Firefox with `yt-dlp --cookies-from-browser`.
2. Tolerate a local validation failure if the cookie file was still successfully exported.
3. POST cookie text to the server API.

## Security notes

- Never hardcode production bearer tokens inside the published skill.
- Keep the Windows wrapper generic and rely on env vars:
  - `MEOW_SERVER_URL`
  - `MEOW_BEARER_TOKEN`
- Write cookie files atomically on the server (`.tmp` then rename).

Credential Access

High

• Category: Privilege Escalation
• Confidence: 70% confidence

Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/install_server_env.sh (reported line 13)May include surrounding context.

sh

apt-get install -y curl ca-certificates gnupg ffmpeg python3 python3-pip

if ! command -v node >/dev/null 2>&1 || ! node -v | grep -Eq '^v22\.'; then
  install -d -m 0755 /etc/apt/keyrings
  curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
  echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_22.x nodistro main" > /etc/apt/sources.list.d/nodesource.list
  apt-get update

Credential Access

High

• Category: Privilege Escalation
• Confidence: 70% confidence

Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/install_server_env.sh (reported line 14)May include surrounding context.

sh

apt-get install -y curl ca-certificates gnupg ffmpeg python3 python3-pip

if ! command -v node >/dev/null 2>&1 || ! node -v | grep -Eq '^v22\.'; then
  install -d -m 0755 /etc/apt/keyrings
  curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
  echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_22.x nodistro main" > /etc/apt/sources.list.d/nodesource.list
  apt-get update

Credential Access

High

• Category: Privilege Escalation
• Confidence: 70% confidence

Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · scripts/install_server_env.sh (reported line 15)May include surrounding context.

sh

apt-get install -y curl ca-certificates gnupg ffmpeg python3 python3-pip

if ! command -v node >/dev/null 2>&1 || ! node -v | grep -Eq '^v22\.'; then
  install -d -m 0755 /etc/apt/keyrings
  curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
  echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_22.x nodistro main" > /etc/apt/sources.list.d/nodesource.list
  apt-get update

Missing User Warnings

High

• Category: Not specified by scanner
• Confidence: 97% confidence

Finding

The script invokes yt-dlp with --cookies-from-browser to extract browser-stored authentication cookies from a named profile, yet there is no disclosure at the point of use that sensitive credential material is being accessed. In the context of a YouTube fallback workflow, this is more dangerous because the skill is explicitly designed to operationalize credential extraction for server-side reuse, increasing the chance of silent overcollection or misuse.

Content

No source excerpt is available for this finding.

Missing User Warnings

High

• Category: Not specified by scanner
• Confidence: 98% confidence

Finding

The script reads exported browser cookies and uploads them to a remote server endpoint using a bearer token, but it provides no explicit consent prompt, scope limitation, or warning that authentication material is being transmitted off-host. In this skill context, the stated purpose is to sync YouTube cookies to a server for media acquisition, which makes the behavior intentional but still highly sensitive because those cookies may enable account access or session hijacking if the destination server is untrusted or compromised.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium

• Category: MCP Least Privilege
• Confidence: 95% confidence

Finding

The skill clearly describes operations requiring shell, file access, network access, and likely environment access, but it declares no explicit tool scope or permission boundaries. That makes the skill harder to review safely and increases the risk that an agent could invoke powerful capabilities unexpectedly while handling cookies, downloads, and server-side setup.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 97% confidence

Finding

The skill instructs exporting browser cookies and posting them to a server endpoint, but it does not prominently warn that cookies are sensitive authentication material that can enable account hijacking if intercepted, logged, or mishandled. In context, these are YouTube/Google session cookies from a real browser profile, so transmitting them is materially dangerous even if done for operational convenience.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 93% confidence

Finding

The document instructs operators to export browser cookies and transmit the raw cookie text to a server, but it does not prominently warn that these cookies are highly sensitive session credentials. Even if intended for YouTube download reliability, moving browser cookies off the local machine expands the trust boundary and can expose authenticated sessions if the server, transport, logs, or downstream handling are compromised.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 92% confidence

Finding

The skill explicitly recommends passing a local YouTube cookies file to yt-dlp, which enables reuse of authenticated browser session material without any warning, consent flow, or handling guidance. In this skill context, the broader description mentions exporting/syncing Windows Chrome cookies to a server, which materially increases the risk of credential misuse, account takeover exposure, and accidental transfer of sensitive session tokens across trust boundaries.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium

• Category: Not specified by scanner
• Confidence: 89% confidence

Finding

The notes instruct operators to use a YouTube cookies file and verify the server can read it, but they do not include any warning that browser-exported cookies are sensitive authentication artifacts equivalent to session tokens. In this skill’s context, the workflow explicitly involves exporting cookies from a Windows Chrome profile and syncing them to a server, which increases the risk of credential leakage, account takeover, and unintended persistence of personal session data.

Content

No source excerpt is available for this finding.

subprocess module call

Medium

• Category: Dangerous Code Execution
• Confidence: 70% confidence

Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/youtube_cookie_sync.py (reported line 23)May include surrounding context.

python

print("+", " ".join(cmd))

    try:
        subprocess.check_call(cmd)
    except subprocess.CalledProcessError:
        if os.path.exists(cookie_txt) and os.path.getsize(cookie_txt) > 100:
            print("cookie 已导出，忽略本地 yt-dlp 校验失败，继续上传...")

Missing User Warnings

Low

• Category: Not specified by scanner
• Confidence: 84% confidence

Finding

The document instructs downloading media with yt-dlp, transcoding with ffmpeg, and writing output files such as source.* and music.mp3. Although these actions are central to the described integration, the markdown provides no user warning about disk writes, external tool execution, or overwriting output via ffmpeg -y.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low

• Category: Not specified by scanner
• Confidence: 88% confidence

Finding

The script emits Chinese-only status text in user-visible output, which imposes a specific language without user opt-in. The file does not indicate that it is intentionally region-specific or provide an option to select another language.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low

• Category: Not specified by scanner
• Confidence: 93% confidence

Finding

The argparse help strings and error message are user-facing natural-language text limited to Chinese. There is no indication that the tool is region-specific or any mechanism for the user to opt into or select this locale.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.