Dieser Bericht ist nicht in der angeforderten Sprache verfügbar. Stattdessen wird der maßgebliche englische Bericht angezeigt.
Versionierte Sicherheitsbewertung
Berichts-ID: SA-6800060F
7/5/2026, 3:34:29 PM
embedded-captions Sicherheitsbewertung v2
Zertifizierungsbericht zur Skill-Sicherheit
Auditmodell: codex Historischer Bericht
- Skillname
- embedded-captions
- Version
- v2
- Betreuer
- heygen-com
- Abdeckung
- 97 Gescannte Dateien · 25,422 Analysierte Zeilen
- Richtlinienversion
- Nicht verfügbar
Höchster bestätigter Schweregrad eines Befunds
Hoch
3 bestätigte Sicherheitsbefunde erfordern Aufmerksamkeit.
Installationskontext
Historische Nachweise
Dieser Bericht beschreibt möglicherweise nicht das derzeit installierbare Artefakt. Öffnen Sie die aktuelle Skill-Seite für Installationshinweise.
Aktuelle Skill-Seite öffnenDieser Bericht blockiert oder autorisiert weder das Manifest noch die ZIP-Datei.
The skill is a legitimate but high-risk local video rendering pipeline. Many static critical detections are false positives from visual theme names and documentation syntax, but the skill still performs real child-process execution, filesystem writes, symlink creation, CDN script loading, and runtime dependency downloads.
Position melden
Historischer Bericht
Öffnen Sie den Auditverlauf, bevor Sie diesen Bericht zur Installation verwenden.
Audit-Nachweis
Nicht bescheinigungsfähig
Die erforderliche unveränderliche Bindung ist unvollständig.
Menschliche Überprüfung
Nicht überprüft
Für diesen Bericht ist keine menschliche Überprüfung verzeichnet.
Abdeckung
97 Gescannte Dateien · 25,422 Analysierte Zeilen
369 Elemente zur Überprüfung angezeigt
Einschränkungen
Dieser Bericht beansprucht keine Laufzeit- oder Sandbox-Ausführung und beweist nicht das Fehlen von Nebenwirkungen.
Beweiskette
Folgen Sie den Nachweisen von der Quellenbindung bis zum Installationsvertrag. Verfügbare Nachweise unterstützen die Überprüfung; sie sind keine Sicherheitsgarantie.
Quelle
Bindung nicht verfügbar
Artefakt
Identität unvollständig
Prüfung
Vollständig
Beobachtete Funktionen
„Beobachtet“ bedeutet, dass dieser Bericht unterstützende Nachweise erfasst hat. Nicht erfasst bedeutet nicht, dass eine Fähigkeit nicht vorhanden ist.
Enthält Skripte
Kann mit dem Skill enthaltenen Code ausführen.
An 12 Nachweisstellen beobachtet
Netzwerkzugriff
Kann eine Verbindung zu externen Diensten herstellen.
An 11 Nachweisstellen beobachtet
Dateisystemzugriff
Kann lokale Dateien lesen oder schreiben.
An 242 Nachweisstellen beobachtet
Umgebungsvariablen
Kann Werte aus der Prozessumgebung lesen.
An 11 Nachweisstellen beobachtet
Externe Befehle
Kann Befehle oder Programme außerhalb des Skills aufrufen.
An 796 Nachweisstellen beobachtet
Elemente der Fähigkeitsprüfung (366)
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
out = cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
cp.execFileSync("node", [path.join(__dirname, "measure-layout.cjs"), project], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Node.js child_process module
const cp2 = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Node.js child_process module
require("child_process").spawnSync(
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
let r = cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
cp2.spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
require("child_process").spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
cp2.spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
r = cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
cp2.spawnSync("node", [path.join(__dirname, "measure-layout.cjs"), project, String(midT)], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Node.js child_process module
const { execFileSync } = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
const out = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
const D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
const D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
const D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
let D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
let D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
let D = execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
.execFileSync("ffprobe", [
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
const r = cp.spawnSync("node", [hfCli(), "remove-background", matteSrc, "-o", mov], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Hidden file in home directory
* weights — the model auto-downloads once (~168 MB) to ~/.cache/hyperframes/.
The skill documents downloads or cache writes under hidden home directories such as ~/.cache/hyperframes. Persistent hidden cache writes require user awareness and provenance checks.
Hoch
Symlink creation
fs.symlinkSync(path.basename(found), src);
The skill creates symlinks for source media or shadow render assets. Symlink creation can expose or overwrite unexpected paths if project directories are untrusted.
Hoch
Symlink creation
ln -sf "$p" "$sh/$b"
The skill creates symlinks for source media or shadow render assets. Symlink creation can expose or overwrite unexpected paths if project directories are untrusted.
Hoch
Node.js child_process module
const cp = require("child_process");
The script imports child_process and the skill pipeline uses it to run ffmpeg, node, uvx, python, or hyperframes tools. That is real local command execution capability.
Hoch
Synchronous file execution
cp.execFileSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
cp.execFileSync("ffmpeg", ["-y", "-i", src, "-vn", "-ac", "1", "-ar", "16000", wav], {
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous file execution
const so = cp.execFileSync("node", [cli, ...args], { encoding: "utf8" });
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
const r = cp.spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
const r = cp.spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
let r = cp.spawnSync("uvx", wxArgs, { encoding: "utf8", timeout: 600000 });
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Synchronous spawn
r = cp.spawnSync(
The script synchronously executes external binaries or Node helpers during transcription, matting, rendering, or validation. Arguments are generally array-based, but local command execution is real.
Hoch
Symlink creation
fs.symlinkSync(path.basename(found), src);
The skill creates symlinks for source media or shadow render assets. Symlink creation can expose or overwrite unexpected paths if project directories are untrusted.
Hoch
Hidden file in home directory
- **Node-first; two Python touchpoints via `uvx` (no manual installs):** transcription runs WhisperX
The skill documents downloads or cache writes under hidden home directories such as ~/.cache/hyperframes. Persistent hidden cache writes require user awareness and provenance checks.
Hoch
Hidden file in home directory
- Matting weights are NOT bundled: `matte.cjs` shells the hyperframes CLI's `remove-background`, whi
The skill documents downloads or cache writes under hidden home directories such as ~/.cache/hyperframes. Persistent hidden cache writes require user awareness and provenance checks.
Mittel
innerHTML assignment (XSS risk)
flow.innerHTML = line.words
The example inserts caption words into innerHTML, which would be unsafe if copied with transcript text that contains markup. The location is documentation, so confidence is moderate.
Mittel
Node.js fs operations
const buf = fs.readFileSync(path.join(FILES, f));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(OUT, header + "\n" + faces.join("\n\n") + "\n");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const buf = fs.readFileSync(path.join(FILES, f));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(OUT, header + "\n" + faces.join("\n\n") + "\n");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Temp directory access
bash scripts/render-and-composite.sh /tmp/ts-${case}
The documented test command writes projects under /tmp, which is normal for tests but still uses shared temporary filesystem space.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "envelope.json"), JSON.stringify({ hop: HOP, rms }));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "envelope.json"), JSON.stringify({ hop: HOP, rms }));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Dynamic require with variable
if (fs.existsSync(c)) return require(c);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bun))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return JSON.parse(fs.readFileSync(lp, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const plan = fs.existsSync(planPath) ? JSON.parse(fs.readFileSync(planPath, "utf8")) : {};
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
return JSON.parse(fs.readFileSync(lp, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const plan = fs.existsSync(planPath) ? JSON.parse(fs.readFileSync(planPath, "utf8")) : {};
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Dynamic require with variable
puppeteer = require(p);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const html = fs.readFileSync(indexPath, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const html = fs.readFileSync(indexPath, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Dynamic require with variable
puppeteer = require(p);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
if (g) gsapSource = fs.readFileSync(g, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
if (g) gsapSource = fs.readFileSync(g, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const plan = JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const t = JSON.parse(fs.readFileSync(path.join(project, "transcript.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const plan = JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const t = JSON.parse(fs.readFileSync(path.join(project, "transcript.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
trWordsRaw = JSON.parse(fs.readFileSync(trPath, "utf8")).words || [];
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
trWordsRaw = JSON.parse(fs.readFileSync(trPath, "utf8")).words || [];
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
css = fs.readFileSync(FONTS_CSS, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
html = fs.readFileSync(file, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(file, html);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(file, html);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
css = fs.readFileSync(FONTS_CSS, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
html = fs.readFileSync(file, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(file, html);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(file, html);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const C = JSON.parse(fs.readFileSync(cj, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const tr = (JSON.parse(fs.readFileSync(tj, "utf8")).words || []).filter(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
sz = JSON.parse(fs.readFileSync(path.join(project, "safe-zones.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.readdirSync(project).filter((x) => /\.(mp4|mov|webm)$/i.test(x)),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
lay = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.unlinkSync(path.join(project, "_layout.json"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const ss = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.unlinkSync(path.join(project, "_layout.json"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples[0].caps ||
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.unlinkSync(path.join(project, "_layout.json"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const C = JSON.parse(fs.readFileSync(cj, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const tr = (JSON.parse(fs.readFileSync(tj, "utf8")).words || []).filter(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
sz = JSON.parse(fs.readFileSync(path.join(project, "safe-zones.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
lay = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const ss = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples[0].caps ||
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
? fs.readFileSync(path.join(TEMPLATES, "engine.html"), "utf8")
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
: fs.readFileSync(findTemplate(plan.template), "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "index.html"), src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "index_fg.html"), fg);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
? fs.readFileSync(path.join(TEMPLATES, "engine.html"), "utf8")
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
: fs.readFileSync(findTemplate(plan.template), "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "index.html"), src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "index_fg.html"), fg);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Shell command substitution
cd "$(dirname "$0")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Template literal with command substitution
`#!/usr/bin/env bash
The compiler writes a shell script containing command substitution into the project. This is expected post-processing behavior, but it expands the local command-execution surface.
Mittel
Node.js fs operations
const theme = JSON.parse(fs.readFileSync(path.join(PROJECT, "theme.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const dna = JSON.parse(fs.readFileSync(path.join(SKILL, "themes", theme.dna + ".json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const transcript = JSON.parse(fs.readFileSync(path.join(PROJECT, "transcript.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.readFileSync(path.join(PROJECT, "matte.fps"), "utf8").replace(/\D/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const n = fs.readdirSync(path.join(PROJECT, "frames_fg")).length;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return JSON.parse(fs.readFileSync(path.join(SKILL, "assets/fonts/char-widths.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.readFileSync(path.join(SKILL, "assets/brand/cyberpunk-widths.json"), "utf8"),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
css = fs.readFileSync(path.join(SKILL, "modes/standard/fonts/fonts.css"), "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.readFileSync(path.join(SKILL, "assets/brand/cyberpunk-widths.json"), "utf8"),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(PROJECT, "index.html"), bgHtml);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(PROJECT, "rail.html"), fgHtml);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.unlinkSync(path.join(PROJECT, "rail.html"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const theme = JSON.parse(fs.readFileSync(path.join(PROJECT, "theme.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const dna = JSON.parse(fs.readFileSync(path.join(SKILL, "themes", theme.dna + ".json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const transcript = JSON.parse(fs.readFileSync(path.join(PROJECT, "transcript.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.readFileSync(path.join(PROJECT, "matte.fps"), "utf8").replace(/\D/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
return JSON.parse(fs.readFileSync(p, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
return JSON.parse(fs.readFileSync(path.join(SKILL, "assets/fonts/char-widths.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.readFileSync(path.join(SKILL, "assets/brand/cyberpunk-widths.json"), "utf8"),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
css = fs.readFileSync(path.join(SKILL, "modes/standard/fonts/fonts.css"), "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.readFileSync(path.join(SKILL, "assets/brand/cyberpunk-widths.json"), "utf8"),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
.readFileSync(path.join(SKILL, "assets/brand/CyberpunkReplica.ttf"))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(PROJECT, "index.html"), bgHtml);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(PROJECT, "rail.html"), fgHtml);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.symlinkSync(path.basename(found), src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.copyFileSync(found, src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.mkdirSync(dst, { recursive: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
if (fs.readdirSync(dst).some((f) => f.endsWith(".png"))) return false;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
return fs.readdirSync(dir).filter((f) => f.endsWith(".png")).length;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fps = parseInt(fs.readFileSync(fpsFile, "utf8").replace(/\D/g, ""), 10) || 0;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(fpsFile, String(fps));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.mkdirSync(framesFg, { recursive: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.rmSync(mov, { force: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.mkdirSync(tmp, { recursive: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.copyFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.rmSync(framesFg, { recursive: true, force: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.renameSync(tmp, framesFg);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.copyFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fps = parseInt(fs.readFileSync(fpsFile, "utf8").replace(/\D/g, ""), 10) || 0;
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(fpsFile, String(fps));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Hidden file access
* weights — the model auto-downloads once (~168 MB) to ~/.cache/hyperframes/.
The referenced dependency cache lives under a hidden home directory. This is expected for model tooling but creates persistent local state outside the project.
Mittel
Dynamic require with variable
puppeteer = require(p);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir)) {
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir)) {
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
gsapSource = fs.readFileSync(p, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
if (fs.existsSync(planPath)) plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
await page.addStyleTag({ content: fs.readFileSync(fontsCss, "utf8") });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(outPath, JSON.stringify(layout, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
gsapSource = fs.readFileSync(p, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
if (fs.existsSync(planPath)) plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
await page.addStyleTag({ content: fs.readFileSync(fontsCss, "utf8") });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(outPath, JSON.stringify(layout, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Shell command substitution
PROJECT="$(cd "$PROJECT" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
SD="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Dynamic require with variable
puppeteer = require(p);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Dynamic require with variable
sharp = require(p);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
if (g) gsapSource = fs.readFileSync(g, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
await page.addStyleTag({ content: fs.readFileSync(fontsCss, "utf8") });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
String(fs.readFileSync(path.join(project, "matte.fps"), "utf8")).replace(/[^\d.]/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8")).caption_layer === "fg";
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const plan = JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
? fs.readdirSync(path.join(project, "frames_bg")).length
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.mkdirSync(outDir, { recursive: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
if (g) gsapSource = fs.readFileSync(g, "utf8");
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
await page.addStyleTag({ content: fs.readFileSync(fontsCss, "utf8") });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
String(fs.readFileSync(path.join(project, "matte.fps"), "utf8")).replace(/[^\d.]/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8")).caption_layer === "fg";
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const plan = JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Dynamic require with variable
PFPS="$(node -e 'try{process.stdout.write(String(require(process.argv[1]).fps??""))}catch(e){}' "$PR
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Dynamic require with variable
FPS="$(node -e 'process.stdout.write(String(require(process.argv[1]).fps??24))' "$PROJECT/plan.json"
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Dynamic require with variable
CAPTION_LAYER="$(node -e 'process.stdout.write(String(require(process.argv[1]).caption_layer??"bg"))
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Shell command substitution
PROJECT="$(cd "$PROJECT" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
SKILL_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
for cand in "${2:-}" "${HYPERFRAMES_ROOT:-}" "$(cd "$SKILL_SCRIPT_DIR/../../.." 2>/dev/null && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
C="$(compiler_for)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/$C" "$PROJECT"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/make-cinematic.cjs" "$PROJECT"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/make-cinematic.cjs" "$PROJECT"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
C="$(compiler_for)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/$C" "$PROJECT"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
C="$(compiler_for)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
ENGINE="$(dirname "$0")/../modes/cinematic/engine.html"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if [[ "$(dirname "$0")/$RECOMPILER" -nt "$PROJECT/index.html" || "$(dirname "$0")/lib-dna.cjs" -nt "
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/$RECOMPILER" "$PROJECT"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/inject-fonts.cjs" "$PROJECT" \
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if ! node "$(dirname "$0")/check-timing.cjs" "$PROJECT" --strict; then
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/check-occlusion.cjs" "$PROJECT" --strict > "$OCC_LOG" 2>&1 &
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if [[ ! -f "$PROJECT/plan.json" && -f "$PROJECT/index.html" && -f "$(dirname "$0")/check-overflow.cj
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
node "$(dirname "$0")/check-overflow.cjs" "$PROJECT" \
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if [[ -f "$PROJECT/rail.html" && -f "$(dirname "$0")/check-overflow.cjs" ]]; then
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if node "$(dirname "$0")/check-overflow.cjs" "$PROJECT" rail.html; then
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if [[ -f "$PROJECT/rail.html" && -f "$PROJECT/index.html" && -f "$(dirname "$0")/check-rail-climax.c
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
if ! node "$(dirname "$0")/check-rail-climax.cjs" "$PROJECT"; then
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
FPS="$(tr -dc '0-9' < "$PROJECT/matte.fps")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
PFPS="$(node -e 'try{process.stdout.write(String(require(process.argv[1]).fps??""))}catch(e){}' "$PR
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
FPS="$(node -e 'process.stdout.write(String(require(process.argv[1]).fps??24))' "$PROJECT/plan.json"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
N="$(ls "$PROJECT/frames_fg" | wc -l | tr -d ' ')"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
DUR="$(grep -oE 'data-duration="[0-9.]+"' "$PROJECT/index.html" | head -1 | grep -oE '[0-9.]+' || ec
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
FPS="$(awk "BEGIN{printf \"%d\", $N/$DUR + 0.5}")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
CAPTION_LAYER="$(node -e 'process.stdout.write(String(require(process.argv[1]).caption_layer??"bg"))
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
ATTR="$(grep -oE 'data-caption-layer="(bg|fg)"' "$PROJECT/index.html" | head -1 | grep -oE '(bg|fg)'
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
STAMP="$(date +%Y%m%d-%H%M%S)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
N_FRAMES="$(ls "$PROJECT/frames_fg" 2>/dev/null | wc -l | tr -d ' ')"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
HF_TIMEOUT_S="${HF_TIMEOUT_S:-$(( N_FRAMES * 3 / 2 > 240 ? N_FRAMES * 3 / 2 : 240 ))}"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
elapsed=$((SECONDS - start))
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
[[ -f "$out" ]] && sz=$(stat -f%z "$out" 2>/dev/null || echo 0)
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
b="$(basename "$p")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
W="$(ffprobe -v error -select_streams v:0 -show_entries stream=width -of default=nw=1:nk=1 "$BG")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
H="$(ffprobe -v error -select_streams v:0 -show_entries stream=height -of default=nw=1:nk=1 "$BG")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
MATTE_DUR="$(awk "BEGIN{printf \"%.3f\", $(ls "$PROJECT/frames_fg" | wc -l)/$FPS}")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
SRC_DUR="$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$PROJECT/source.mp4" 2>/dev/n
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
MATTE_DUR="$(awk "BEGIN{m=$MATTE_DUR; s=$SRC_DUR; printf \"%.3f\", (s>0 && s<m) ? s : m}")"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
BG_DUR="$(ffprobe -v error -show_entries format=duration -of default=nokey=1:noprint_wrappers=1 "$BG
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
PROJECT="$(cd "$PROJECT" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Shell command substitution
SD="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
The shell script uses command substitution while resolving paths or reading project metadata. Variables are mostly quoted, but the skill still executes local shell commands during normal operation.
Mittel
Dynamic require with variable
sharp = require(c);
The skill resolves dependencies or JSON inputs dynamically instead of using a pinned import path. This is intended tooling, but it can load code or data from mutable local locations.
Mittel
Node.js fs operations
for (const d of fs.readdirSync(bunDir))
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
words = (JSON.parse(fs.readFileSync(tp, "utf8")).words || []).filter((w) => w && "start" in w);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
String(fs.readFileSync(path.join(project, "matte.fps"), "utf8")).replace(/[^\d.]/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(path.join(project, "safe-zones.json"), JSON.stringify(out, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
words = (JSON.parse(fs.readFileSync(tp, "utf8")).words || []).filter((w) => w && "start" in w);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
String(fs.readFileSync(path.join(project, "matte.fps"), "utf8")).replace(/[^\d.]/g, ""),
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(path.join(project, "safe-zones.json"), JSON.stringify(out, null, 2));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.symlinkSync(path.basename(found), src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.copyFileSync(found, src);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const d = JSON.parse(fs.readFileSync(out, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.mkdirSync(outDir, { recursive: true });
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const wxJson = JSON.parse(fs.readFileSync(path.join(outDir, "_wx_audio.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.unlinkSync(wav);
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
const flat = JSON.parse(fs.readFileSync(flatPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Node.js fs operations
fs.writeFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const d = JSON.parse(fs.readFileSync(out, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const wxJson = JSON.parse(fs.readFileSync(path.join(outDir, "_wx_audio.json"), "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
const flat = JSON.parse(fs.readFileSync(flatPath, "utf8"));
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Synchronous file operations
fs.writeFileSync(
The script reads and writes project media, transcripts, generated HTML, plans, and render outputs. This filesystem access is intentional but real and should be sandboxed.
Mittel
Hidden file access
- **Node-first; two Python touchpoints via `uvx` (no manual installs):** transcription runs WhisperX
The referenced dependency cache lives under a hidden home directory. This is expected for model tooling but creates persistent local state outside the project.
Mittel
Hidden file access
- Matting weights are NOT bundled: `matte.cjs` shells the hyperframes CLI's `remove-background`, whi
The referenced dependency cache lives under a hidden home directory. This is expected for model tooling but creates persistent local state outside the project.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Node.js fs stat operations
const outKb = Math.round(fs.statSync(OUT).size / 1024);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Hardcoded URL
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) return p;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bun))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(c)) return require(c);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
let stale = force || !fs.existsSync(lp);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!stale && fs.existsSync(idx) && fs.statSync(idx).mtimeMs > fs.statSync(lp).mtimeMs)
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(png)) return null;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(framesDir)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const plan = fs.existsSync(planPath) ? JSON.parse(fs.readFileSync(planPath, "utf8")) : {};
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(indexPath)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
executablePath: fs.existsSync(exe) ? exe : undefined,
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) return p;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(railPath) || !fs.existsSync(indexPath))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
executablePath: fs.existsSync(exe) ? exe : undefined,
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(p)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(cj)) die(`missing ${cj} — author it first (schema in this header)`);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(tj)) die(`missing ${tj} — run prepare.sh first`);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(fp)) continue;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(p)) continue;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) return p;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
.filter((d) => fs.existsSync(path.join(TEMPLATES, d, "template.html")))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(planPath)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Hardcoded URL
const GSAP = `<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>`;
The HTML includes a remote jsDelivr GSAP script, so rendering can contact a third-party CDN and execute remote JavaScript unless assets are vendored.
Niedrig
Node.js fs stat operations
} else if (fs.existsSync(path.join(PROJECT, "rail.html"))) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(cli)) return cli;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(src)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(src)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(cfr)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const cached = fs.existsSync(
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (r.status !== 0 || !fs.existsSync(mov)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(indexPath)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(planPath)) plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
executablePath: fs.existsSync(exe) ? exe : undefined,
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(fontsCss))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(p)) return p;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(fontsCss))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(idx)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const hasRail = fs.existsSync(railP);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const hasFg = fs.existsSync(fgP); // hybrid: fg caps render ABOVE the matte (like the real composite
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const n = fs.existsSync(path.join(project, "frames_bg"))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
executablePath: fs.existsSync(exe) ? exe : undefined,
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(bg)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!globalFg && fs.existsSync(fg)) layers.push({ input: fg }); // subject occludes embed
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(bunDir))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(c)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(tp)) return [];
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(fgDir)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
const hasBg = fs.existsSync(bgDir);
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (hasBg && fs.existsSync(path.join(bgDir, frames[i]))) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (hasBg && fs.existsSync(midBg)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(path.join(r, "packages", "cli", "dist", "cli.js"))) return r;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (fs.existsSync(src)) return src;
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
let found = cands.sort((a, b) => fs.statSync(b).size - fs.statSync(a).size)[0];
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(src)) {
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Node.js fs stat operations
if (!fs.existsSync(audio))
The script inspects file existence or size while resolving project assets and dependencies. This is low-risk filesystem access but still touches local paths.
Niedrig
Environment variable access (dot notation)
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable access (dot notation)
const model = process.argv[3] || process.env.WHISPER_MODEL || "small";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable access (dot notation)
const language = process.argv[4] || process.env.WHISPER_LANG || "";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable access (dot notation)
const wantWx = (process.env.TRANSCRIBE_ENGINE || "whisperx") === "whisperx";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
process.env.HYPERFRAMES_ROOT,
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
const model = process.argv[3] || process.env.WHISPER_MODEL || "small";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
const language = process.argv[4] || process.env.WHISPER_LANG || "";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Niedrig
Environment variable object
const wantWx = (process.env.TRANSCRIBE_ENGINE || "whisperx") === "whisperx";
The code reads environment variables such as HYPERFRAMES_ROOT or WHISPER settings to choose local tool roots and models. This is configuration, but it can change executed code paths.
Risikofunde
Bestätigte Sicherheitsbedenken werden von Punkten getrennt, die noch überprüft werden müssen.
Bestätigte Sicherheitsbedenken (3)
RISK-001 Hoch
Unpinned Global Skill Auto-Update
The instructions state that initialization checks installed skills against GitHub and updates the global set when out of date. This can change globally installed skill behavior during a caption setup step.
The behavior is explicitly documented on line 120. I did not verify the external CLI implementation, so confidence is high but not absolute.
RISK-002 Hoch
Runtime Download and Execution Supply Chain
The skill relies on uvx WhisperX and hyperframes model downloads during normal operation. This executes or stores third-party code and model artifacts outside the project directory.
The dependency and model download behavior is stated directly in the dependency section. The static findings also show matching child_process and hidden-cache usage.
RISK-003 Niedrig
Unscanned file (too_large) — manual review required
[unscanned: too_large]
This binary or oversized asset was not statically inspected. It appears to be a font asset, but marketplace review should verify provenance before publication.
Abhilfemaßnahmen
Von diesem Audit vorgeschlagene Korrekturen wurden erfasst. Ihre Umsetzung liegt in der Verantwortung des Maintainers.
- FIX-001HochLocal command execution is required for transcription, matting, validation, and ffmpeg compositing.Require explicit user confirmation before running scripts, pin executable paths, and document every external binary invoked by the pipeline.
- FIX-002HochInitialization and dependencies can update or download code and model artifacts from the network.Pin versions and hashes for packages, models, and global skill updates. Provide an offline or vendored mode for marketplace installs.
- FIX-003MittelGenerated HTML loads GSAP from a public CDN in several templates.Vendor GSAP with integrity verification or load a reviewed local copy instead of executing remote CDN JavaScript.
- FIX-004MittelThe pipeline creates project symlinks and writes generated outputs into user-selected directories.Restrict execution to a dedicated project sandbox and reject paths outside that sandbox before linking or writing files.
- FIX-005NiedrigMany bundled font binaries and one large CSS file were not statically scanned.Verify font provenance, retain license records, and scan binary assets with a dedicated artifact review process.
Expertennachweise
Unveränderliche Subjektidentität, Scanner-Metadaten, verworfene Treffer und Nachweise auf Quellcodeebene.
Artefakt-Subjekt
- Marketplace-Commit
- Nicht verfügbar
- Inhalts-Hash
- Nicht verfügbar
- Tree-Hash
- Nicht verfügbar
- Skill-Pfad
- Nicht verfügbar
- Hash der Audit-Nutzlast
- Nicht verfügbar
Analysemetadaten
Auditmodell: codex
Analysestatus: Vollständig
Der Umfang ist auf die aufgezeichneten Dateien, Zeilen, Methoden und Nachweise beschränkt. Es wird keine Ausführung in einer Laufzeitumgebung oder Sandbox beansprucht.
Statische falsch positive Treffer ignoriert (9)
Kritisch
Ransom message keywords
| `ransom` | cutout-chip collage rail + ransom-note slam apex | kidnapper's collage — e
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
// ransom-note letter chips (demo: 10 chips, 4 recipes/fonts cycled, base
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
// ---- ransom shared pieces: the cutout-chip recipes and the seeded paper-tear
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
// The hero word slams in BEHIND the subject as a ransom note: one cutout
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
// ===== letter-by-letter ransom slam: S_k = I + 0.01 + STEP*k, contact = S_k + CRUSH
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
description: 'Add captions to a talking-head video. ONE catalog (CATALOG.md) of 32 visual identities
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
"name": "ransom",
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
"voice": "kidnapper's collage — every word is a cutout chip clipped from a different page (cream Ant
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Kritisch
Ransom message keywords
| `ransomnote` | RANSOM NOTE slam behind the subject: one cutout chip per letter (4 recipes cycled,
Force-confirmed blocker/critical static finding; AI dismissal overridden.
Verifizieren und exportieren
Das Manifest und die Lockdatei binden Installationsartefakte an kryptografische Hashes. Diese Integritätsaussage ist von der Sicherheitsbewertung getrennt.
Audit-Nachweis: not_attestable