@floomhq/floom 1.0.14 → 1.0.17

package/dist/package.js

@@ -0,0 +1,318 @@
+import { constants } from "node:fs";
+import { lstat, open, readdir, readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { FloomError } from "./errors.js";
+const ALLOWED_PACKAGE_DIRS = new Set(["references", "examples", "scripts", "assets"]);
+const ALLOWED_PACKAGE_ROOT_FILES = new Set(["SKILL.md", ".gitignore"]);
+const PACKAGE_FILE_LIMIT = 100;
+const PACKAGE_TOTAL_BYTES_LIMIT = 1_000_000;
+const PACKAGE_FILE_BYTES_LIMIT = 500_000;
+const PACKAGE_SEGMENT_RE = /^[A-Za-z0-9._-]{1,128}$/;
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const execFile = promisify(execFileCb);
+export function sha256Bytes(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+export async function readSkillPackage(inputPath) {
+    const resolved = resolve(process.cwd(), inputPath);
+    let stat;
+    try {
+        stat = await lstat(resolved);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new FloomError(`File not found: ${inputPath}`);
+        }
+        throw new FloomError(`Couldn't read ${inputPath}: ${err.message}`);
+    }
+    if (stat.isSymbolicLink()) {
+        throw new FloomError(`Package path is a symbolic link: ${inputPath}`);
+    }
+    if (stat.isFile()) {
+        const body = await readSkillFile(resolved, inputPath);
+        return {
+            rootPath: dirname(resolved),
+            skillPath: resolved,
+            skillBody: body,
+            packageFiles: [],
+            originalFilename: basename(resolved),
+            isFolder: false,
+        };
+    }
+    if (!stat.isDirectory()) {
+        throw new FloomError(`That's not a file or skill folder: ${inputPath}`);
+    }
+    const skillPath = join(resolved, "SKILL.md");
+    const skillBody = await readSkillFile(skillPath, join(inputPath, "SKILL.md"));
+    const packageFiles = await collectPackageFiles(resolved);
+    return {
+        rootPath: resolved,
+        skillPath,
+        skillBody,
+        packageFiles,
+        originalFilename: `${basename(resolved)}/SKILL.md`,
+        isFolder: true,
+    };
+}
+async function readSkillFile(path, label) {
+    let body;
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile())
+                throw new FloomError(`That's a directory, not a file: ${label}`);
+            if (stat.size > PACKAGE_FILE_BYTES_LIMIT) {
+                throw new FloomError(`File too large: ${label}`, "Each package file is capped at 500KB.");
+            }
+            body = await handle.readFile("utf8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            throw new FloomError(`File not found: ${label}`);
+        if (code === "ELOOP")
+            throw new FloomError(`Package file is a symbolic link: ${label}`);
+        if (err instanceof FloomError)
+            throw err;
+        throw new FloomError(`Couldn't read ${label}: ${err.message}`);
+    }
+    if (!body.trim()) {
+        throw new FloomError(`File is empty: ${label}`, "Add skill instructions before scanning or publishing.");
+    }
+    return body;
+}
+async function collectPackageFiles(root) {
+    const files = [];
+    let totalBytes = Buffer.byteLength(await readFile(join(root, "SKILL.md")));
+    const isIgnored = gitIgnoreChecker(root);
+    const rootEntries = await readdir(root, { withFileTypes: true });
+    for (const entry of rootEntries) {
+        if (ALLOWED_PACKAGE_ROOT_FILES.has(entry.name) || ALLOWED_PACKAGE_DIRS.has(entry.name))
+            continue;
+        if (await isIgnored(entry.name))
+            continue;
+        const hint = "Move supporting files under references/, examples/, scripts/, or assets/.";
+        throw new FloomError(`Unsupported root package entry: ${entry.name}`, hint);
+    }
+    for (const dirName of ALLOWED_PACKAGE_DIRS) {
+        const dirPath = join(root, dirName);
+        let stat;
+        try {
+            stat = await lstat(dirPath);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        if (await isIgnored(dirName))
+            continue;
+        if (stat.isSymbolicLink())
+            throw new FloomError(`Package directory is a symbolic link: ${dirName}`);
+        if (!stat.isDirectory())
+            throw new FloomError(`Package entry must be a directory: ${dirName}`);
+        await collectDir(root, dirPath, files, isIgnored, (size) => {
+            totalBytes += size;
+            if (totalBytes > PACKAGE_TOTAL_BYTES_LIMIT) {
+                throw new FloomError("Skill package is too large.", "A skill package is capped at 1MB total.");
+            }
+        });
+    }
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function collectDir(root, dir, files, isIgnored, addBytes) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!PACKAGE_SEGMENT_RE.test(entry.name)) {
+            throw new FloomError(`Invalid package path segment: ${entry.name}`);
+        }
+        const fullPath = join(dir, entry.name);
+        const rel = packageRelativePath(root, fullPath);
+        if (await isIgnored(rel))
+            continue;
+        if (entry.isSymbolicLink())
+            throw new FloomError(`Package path is a symbolic link: ${rel}`);
+        if (entry.isDirectory()) {
+            await collectDir(root, fullPath, files, isIgnored, addBytes);
+            continue;
+        }
+        if (!entry.isFile())
+            throw new FloomError(`Package path is not a regular file: ${rel}`);
+        if (files.length >= PACKAGE_FILE_LIMIT) {
+            throw new FloomError("Skill package has too many files.", "A skill package is capped at 100 supporting files.");
+        }
+        const stat = await lstat(fullPath);
+        if (stat.isSymbolicLink())
+            throw new FloomError(`Package path is a symbolic link: ${rel}`);
+        if (!stat.isFile())
+            throw new FloomError(`Package path is not a regular file: ${rel}`);
+        if (stat.size > PACKAGE_FILE_BYTES_LIMIT) {
+            throw new FloomError(`File too large: ${rel}`, "Each package file is capped at 500KB.");
+        }
+        addBytes(stat.size);
+        const bytes = await readFile(fullPath);
+        files.push({
+            path: rel,
+            content_base64: bytes.toString("base64"),
+            encoding: "base64",
+            size_bytes: bytes.length,
+            sha256: sha256Bytes(bytes),
+        });
+    }
+}
+function gitIgnoreChecker(root) {
+    const cache = new Map();
+    let localRules = null;
+    return async (rel) => {
+        const cached = cache.get(rel);
+        if (cached !== undefined)
+            return cached;
+        let ignored = false;
+        try {
+            await execFile("git", ["-C", root, "check-ignore", "--quiet", "--", rel]);
+            ignored = true;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 1 && code !== 128 && code !== "ENOENT") {
+                ignored = false;
+            }
+            if (code === 128 || code === "ENOENT") {
+                localRules ??= readLocalGitignore(root);
+                ignored = matchesLocalGitignore(rel, await localRules);
+            }
+        }
+        cache.set(rel, ignored);
+        return ignored;
+    };
+}
+async function readLocalGitignore(root) {
+    try {
+        const body = await readFile(join(root, ".gitignore"), "utf8");
+        return body
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("!"));
+    }
+    catch {
+        return [];
+    }
+}
+function matchesLocalGitignore(rel, rules) {
+    const normalized = rel.replace(/\\/g, "/").replace(/^\/+/, "");
+    for (const rawRule of rules) {
+        const rule = rawRule.replace(/\\/g, "/").replace(/^\/+/, "");
+        if (!rule)
+            continue;
+        if (rule.endsWith("/")) {
+            const prefix = rule.replace(/\/+$/, "");
+            if (normalized === prefix || normalized.startsWith(`${prefix}/`))
+                return true;
+            continue;
+        }
+        if (normalized === rule || normalized.endsWith(`/${rule}`))
+            return true;
+    }
+    return false;
+}
+function packageRelativePath(root, path) {
+    const rel = relative(resolve(root), resolve(path));
+    if (!rel || rel === "." || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+        throw new FloomError("Invalid package path.");
+    }
+    const normalized = rel.split(sep).join("/");
+    validatePackageRelativePath(normalized);
+    return normalized;
+}
+export function validatePackageRelativePath(path) {
+    if (!path || isAbsolute(path) || path.includes("\\") || path.length > 512) {
+        throw new FloomError(`Invalid package file path: ${path}`);
+    }
+    const segments = path.split("/");
+    if (segments.length < 2 || !ALLOWED_PACKAGE_DIRS.has(segments[0] ?? "")) {
+        throw new FloomError(`Invalid package file path: ${path}`, "Package files must be under references/, examples/, scripts/, or assets/.");
+    }
+    if (segments.some((segment) => segment === "." || segment === ".." || !PACKAGE_SEGMENT_RE.test(segment))) {
+        throw new FloomError(`Invalid package file path: ${path}`);
+    }
+}
+export function normalizeRemotePackageFiles(input) {
+    if (input === undefined || input === null)
+        return [];
+    if (!Array.isArray(input))
+        throw new FloomError("Invalid skill package response.");
+    if (input.length > PACKAGE_FILE_LIMIT) {
+        throw new FloomError("Skill package response has too many files.");
+    }
+    let totalBytes = 0;
+    const seenPaths = new Set();
+    return input.map((raw) => {
+        if (!raw || typeof raw !== "object")
+            throw new FloomError("Invalid skill package response.");
+        const file = raw;
+        if (typeof file.path !== "string")
+            throw new FloomError("Invalid skill package response.");
+        validatePackageRelativePath(file.path);
+        const pathKey = file.path.toLowerCase();
+        if (seenPaths.has(pathKey))
+            throw new FloomError(`Duplicate package file: ${file.path}`);
+        seenPaths.add(pathKey);
+        let bytes;
+        if (typeof file.content_base64 === "string") {
+            if (file.encoding !== undefined && file.encoding !== "base64") {
+                throw new FloomError(`Invalid package file encoding: ${file.path}`);
+            }
+            if (file.content_base64.length % 4 !== 0 || !BASE64_RE.test(file.content_base64)) {
+                throw new FloomError(`Invalid package file base64: ${file.path}`);
+            }
+            bytes = Buffer.from(file.content_base64, "base64");
+        }
+        else if (typeof file.content === "string") {
+            bytes = Buffer.from(file.content, "utf8");
+        }
+        else {
+            throw new FloomError("Invalid skill package response.");
+        }
+        if (bytes.length > PACKAGE_FILE_BYTES_LIMIT) {
+            throw new FloomError(`Package file is too large: ${file.path}`);
+        }
+        if (typeof file.size_bytes === "number" && file.size_bytes !== bytes.length) {
+            throw new FloomError(`Package file size mismatch: ${file.path}`);
+        }
+        totalBytes += bytes.length;
+        if (totalBytes > PACKAGE_TOTAL_BYTES_LIMIT) {
+            throw new FloomError("Skill package response is too large.");
+        }
+        const hash = sha256Bytes(bytes);
+        if (typeof file.content_base64 === "string" && typeof file.sha256 !== "string") {
+            throw new FloomError(`Package file missing sha256: ${file.path}`);
+        }
+        if (typeof file.sha256 === "string" && file.sha256 !== hash) {
+            throw new FloomError(`Package file hash mismatch: ${file.path}`);
+        }
+        return { path: file.path, bytes, sha256: hash };
+    }).sort((a, b) => a.path.localeCompare(b.path));
+}
+export function packageHash(skillBody, files) {
+    const hash = createHash("sha256");
+    hash.update("SKILL.md\0");
+    hash.update(skillBody);
+    for (const file of files) {
+        hash.update("\0");
+        hash.update(file.path);
+        hash.update("\0");
+        if ("bytes" in file)
+            hash.update(file.bytes);
+        else
+            hash.update(Buffer.from(file.content_base64, "base64"));
+    }
+    return hash.digest("hex");
+}

package/dist/publish.js

@@ -1,5 +1,3 @@
-import { readFile } from "node:fs/promises";
-import { basename, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
 import ora from "ora";
 import clipboard from "clipboardy";
@@ -9,6 +7,7 @@ import { c, symbols } from "./ui.js";
 import { FloomError, friendlyHttp } from "./errors.js";
 import { formatVersionLabel } from "./version.js";
 import { detectSkillSecurityFindings, formatSecurityFindings } from "./secrets.js";
+import { readSkillPackage } from "./package.js";
 const ASSET_TYPES = new Set(["knowledge", "instruction", "workflow", "skill"]);
 const INSTALL_TARGETS = new Set([
     "claude_skill",
@@ -108,33 +107,28 @@ function parseVersion(value, source) {
     throw new FloomError(`Invalid ${source}: ${value}`, "Use 1-64 characters: letters, numbers, dots, underscores, plus, or hyphen.");
 }
 export async function publish(opts) {
-    const filePath = resolve(process.cwd(), opts.file);
-    let raw;
-    try {
-        raw = await readFile(filePath, "utf8");
-    }
-    catch (e) {
-        const code = e.code;
-        if (code === "ENOENT") {
-            throw new FloomError(`File not found: ${opts.file}`);
-        }
-        if (code === "EISDIR") {
-            throw new FloomError(`That's a directory, not a file: ${opts.file}`);
-        }
-        throw new FloomError(`Couldn't read ${opts.file}: ${e.message}`);
-    }
-    if (!raw.trim()) {
-        throw new FloomError(`File is empty: ${opts.file}`);
-    }
-    const securityFindings = detectSkillSecurityFindings(raw);
-    if (securityFindings.length > 0) {
-        throw new FloomError("Security scan failed. Publish stopped.", `${formatSecurityFindings(securityFindings)}\nRemove secrets, prompt-injection text, or data-exfiltration instructions before publishing.`);
-    }
-    process.stdout.write(`\n${symbols.ok}  Pre-publish security scan passed (3 checks).\n`);
-    const { meta, error: fmError } = parseFrontmatter(raw);
+    const skillPackage = await readSkillPackage(opts.file);
+    const securityFailures = [
+        { path: "SKILL.md", body: skillPackage.skillBody },
+        ...skillPackage.packageFiles.map((file) => ({
+            path: file.path,
+            body: Buffer.from(file.content_base64, "base64").toString("utf8"),
+        })),
+    ].flatMap((file) => {
+        const findings = detectSkillSecurityFindings(file.body);
+        return findings.length > 0 ? [`${file.path}\n${formatSecurityFindings(findings)}`] : [];
+    });
+    if (securityFailures.length > 0) {
+        throw new FloomError("Security scan failed. Publish stopped.", `${securityFailures.join("\n")}\nRemove secrets, prompt-injection text, or data-exfiltration instructions before publishing.`);
+    }
+    const fileCount = 1 + skillPackage.packageFiles.length;
+    process.stdout.write(`\n${symbols.ok}  Pre-publish security scan passed (${fileCount} file${fileCount === 1 ? "" : "s"}, 3 checks).\n`);
+    const { meta, error: fmError } = parseFrontmatter(skillPackage.skillBody);
     if (fmError) {
         throw new FloomError(`Couldn't parse frontmatter — check your YAML.`, `Line ${fmError.line}: ${fmError.message}`);
     }
+    validateTextMeta(meta.title, "frontmatter title", 200);
+    validateTextMeta(meta.description, "frontmatter description", 1000);
     const assetType = opts.assetType ?? parseAssetType(meta.asset_type ?? meta.type, "frontmatter type") ?? "skill";
     const installsAs = opts.installsAs ?? parseInstallsAs(meta.installs_as, "frontmatter installs_as") ?? null;
     const version = opts.version ?? parseVersion(meta.version, "frontmatter version") ?? null;
@@ -150,25 +144,27 @@ export async function publish(opts) {
         color: "yellow",
     }).start();
     const apiUrl = resolveApiUrl(cfg);
+    const body = {
+        title: meta.title ?? null,
+        description: meta.description ?? null,
+        body_md: skillPackage.skillBody,
+        visibility: opts.visibility,
+        asset_type: assetType,
+        source: "markdown",
+        installs_as: installsAs,
+        version,
+        original_filename: skillPackage.originalFilename,
+        published_via: "cli",
+        ...(opts.sharedWithEmails ? { shared_with_emails: opts.sharedWithEmails } : {}),
+        ...(skillPackage.packageFiles.length > 0 ? { package_files: skillPackage.packageFiles } : {}),
+    };
     let res;
     try {
         res = await floomFetch(`${apiUrl}/api/skills`, "publish your skill", {
             method: "POST",
             token: cfg.accessToken,
             checkOk: false,
-            body: {
-                title: meta.title ?? null,
-                description: meta.description ?? null,
-                body_md: raw,
-                visibility: opts.visibility,
-                asset_type: assetType,
-                source: "markdown",
-                installs_as: installsAs,
-                version,
-                original_filename: basename(filePath),
-                published_via: "cli",
-                shared_with_emails: opts.sharedWithEmails,
-            },
+            body,
         });
     }
     catch (err) {
@@ -192,17 +188,10 @@ export async function publish(opts) {
     spinner.stop();
     const versionTag = version ? c.dim(` (${formatVersionLabel(version)})`) : "";
     const titleLabel = data.title ? `"${data.title}"` : opts.file;
-    const invitedEmails = opts.sharedWithEmails ?? [];
     process.stdout.write(`\n${symbols.ok}  Published ${c.bold(titleLabel)}${versionTag}\n\n`);
-    process.stdout.write(`   ${c.bold("Send this to someone:")}\n`);
     process.stdout.write(`   ${c.cyan(humanUrl)}\n\n`);
-    process.stdout.write(`   ${c.bold("They run:")}\n`);
-    process.stdout.write(`   ${c.cyan(`npx -y @floomhq/floom add ${humanUrl} --setup`)}\n\n`);
-    process.stdout.write(`   ${c.bold("Your library:")}\n`);
-    process.stdout.write(`   ${c.dim("Your account owns this published skill. Run `npx -y @floomhq/floom sync` or connect MCP to keep your saved, published, and followed library skills local.")}\n\n`);
-    if (invitedEmails.length) {
-        process.stdout.write(`   ${c.bold("Email invite:")}\n`);
-        process.stdout.write(`   ${c.dim(invitedEmails.join(", "))}\n\n`);
+    if (data.visibility === "shared" && data.shared_with_emails?.length) {
+        process.stdout.write(`   ${c.dim(`Shared with ${data.shared_with_emails.join(", ")}`)}\n\n`);
     }
     let copied = false;
     try {
@@ -213,11 +202,22 @@ export async function publish(opts) {
         copied = false;
     }
     if (copied) {
-        process.stdout.write(`   ${c.dim("Copied link to clipboard.")}\n\n`);
+        process.stdout.write(`   ${c.dim("Copied to clipboard. Share it anywhere.")}\n\n`);
     }
     else {
         process.stdout.write(`   ${c.dim("Share it anywhere.")}\n\n`);
     }
-    process.stdout.write(`   ${c.bold("Agent prompt:")}\n`);
-    process.stdout.write(`   ${c.cyan("npx -y @floomhq/floom agent-prompt")}\n\n`);
+    process.stdout.write(`   ${c.bold("Next")}\n`);
+    process.stdout.write(`   ${c.dim("1.")} Test locally: ${c.cyan(`npx -y @floomhq/floom add ${humanUrl} --setup`)}\n`);
+    process.stdout.write(`   ${c.dim("2.")} Send the link.\n`);
+    process.stdout.write(`   ${c.dim("3.")} Receiver runs ${c.cyan(`npx -y @floomhq/floom add ${humanUrl} --setup`)}\n`);
+    process.stdout.write(`   ${c.dim("4.")} Agent reads the installed Markdown from the local skills folder.\n\n`);
+}
+function validateTextMeta(value, label, maxLength) {
+    if (value === undefined)
+        return;
+    if (!value.trim())
+        throw new FloomError(`Invalid ${label}.`, "Metadata values cannot be blank.");
+    if (value.length > maxLength)
+        throw new FloomError(`Invalid ${label}.`, `Use ${maxLength} characters or fewer.`);
 }

package/dist/scan.js

@@ -1,29 +1,24 @@
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
 import { detectSkillSecurityFindings, formatSecurityFindings } from "./secrets.js";
 import { FloomError } from "./errors.js";
 import { c, symbols } from "./ui.js";
-export async function scanSkill(file) {
-    const path = resolve(process.cwd(), file);
-    let raw;
-    try {
-        raw = await readFile(path, "utf8");
+import { readSkillPackage } from "./package.js";
+export async function scanSkill(inputPath) {
+    const skillPackage = await readSkillPackage(inputPath);
+    const failures = [
+        { path: "SKILL.md", body: skillPackage.skillBody },
+        ...skillPackage.packageFiles.map((file) => ({
+            path: file.path,
+            body: Buffer.from(file.content_base64, "base64").toString("utf8"),
+        })),
+    ].flatMap((file) => {
+        const findings = detectSkillSecurityFindings(file.body);
+        return findings.length > 0 ? [`${file.path}\n${formatSecurityFindings(findings)}`] : [];
+    });
+    if (failures.length > 0) {
+        throw new FloomError("Security scan failed.", `${failures.join("\n")}\nRemove secrets, prompt-injection text, or data-exfiltration instructions before publishing.`);
     }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            throw new FloomError(`File not found: ${file}`);
-        if (code === "EISDIR")
-            throw new FloomError(`That's a directory, not a file: ${file}`);
-        throw new FloomError(`Couldn't read ${file}: ${err.message}`);
-    }
-    if (!raw.trim()) {
-        throw new FloomError(`File is empty: ${file}`, "Add skill instructions before scanning or publishing.");
-    }
-    const findings = detectSkillSecurityFindings(raw);
-    if (findings.length > 0) {
-        throw new FloomError("Security scan failed.", `${formatSecurityFindings(findings)}\nRemove secrets, prompt-injection text, or data-exfiltration instructions before publishing.`);
-    }
-    process.stdout.write(`\n${symbols.ok}  Security scan passed for ${c.bold(file)}\n`);
+    const fileCount = 1 + skillPackage.packageFiles.length;
+    process.stdout.write(`\n${symbols.ok}  Security scan passed for ${c.bold(inputPath)}\n`);
+    process.stdout.write(`   ${c.dim(`Checked ${fileCount} package file${fileCount === 1 ? "" : "s"}.`)}\n`);
     process.stdout.write(`   ${c.dim("No high-confidence secrets, prompt-injection text, or exfiltration instructions found.")}\n\n`);
 }

package/dist/secrets.js

@@ -5,29 +5,15 @@ const SECRET_PATTERNS = [
     { label: "Google API key", regex: /\bAIza[0-9A-Za-z_-]{25,}\b/g },
     { label: "GitHub token", regex: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{30,}\b/g },
     { label: "GitHub token", regex: /\bgithub_pat_[A-Za-z0-9_]{40,}\b/g },
-    { label: "npm token", regex: /\bnpm_[A-Za-z0-9]{30,}\b/g },
     { label: "Supabase access token", regex: /\bsbp_[A-Za-z0-9]{30,}\b/g },
     { label: "Stripe secret key", regex: /\bsk_(?:live|test)_[A-Za-z0-9]{20,}\b/g },
     { label: "Slack token", regex: /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g },
     { label: "AWS access key", regex: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g },
-    { label: "Database URL with password", regex: /\b(?:postgres|postgresql|mysql|mongodb(?:\+srv)?|redis):\/\/[^:\s/@]+:[^@\s]{8,}@[^\s]+/gi },
     { label: "Private key", regex: /-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g },
 ];
 const GENERIC_ASSIGNMENT_RE = /\b(?:api[_-]?key|secret|access[_-]?token|auth[_-]?token|bearer[_-]?token)\b\s*[:=]\s*["']?([A-Za-z0-9_./+=-]{24,})["']?/gi;
 const PROVIDER_LIKE_ASSIGNMENT_RE = /\b(?:api[_-]?key|secret|access[_-]?token|auth[_-]?token|bearer[_-]?token)\b\s*[:=]\s*["']?((?:sk|pk|rk)-[A-Za-z0-9_-]{8,}|sbp_[A-Za-z0-9]{12,}|xox[baprs]-[A-Za-z0-9-]{12,})["']?/gi;
-const PLACEHOLDER_RE = /(?:^|[_./+=-])(?:your|example|sample|mock|placeholder|replace|changeme|todo|xxx|demo|dummy|fake|redacted)(?:$|[_./+=-])/i;
-const PLACEHOLDER_PHRASE_WORDS = new Set([
-    "and",
-    "fake",
-    "is",
-    "key",
-    "long",
-    "looks",
-    "real",
-    "secret",
-    "that",
-    "very",
-]);
+const PLACEHOLDER_RE = /(?:^|[_./+=-])(?:your|example|placeholder|replace|changeme|todo|xxx|demo|dummy|fake|redacted)(?:$|[_./+=-])/i;
 const PROMPT_INJECTION_PATTERNS = [
     { label: "Prompt injection instruction", regex: /\bignore (?:all )?(?:previous|prior|above|earlier) instructions\b/gi },
     { label: "Prompt injection instruction", regex: /\bdisregard (?:all )?(?:previous|prior|above|earlier) instructions\b/gi },
@@ -37,14 +23,8 @@ const PROMPT_INJECTION_PATTERNS = [
 ];
 const DATA_EXFILTRATION_PATTERNS = [
     { label: "Data exfiltration instruction", regex: /\b(?:send|post|upload|exfiltrate|copy) (?:[^.\n]{0,80})\b(?:api keys?|tokens?|secrets?|environment variables|\.env|credentials)\b(?:[^.\n]{0,120})\b(?:to|into) https?:\/\//gi },
-    { label: "Data exfiltration instruction", regex: /\b(?:send|post|upload|exfiltrate|copy)\b[^.\n]{0,120}(?:~\/\.ssh\/[A-Za-z0-9_.-]+|id_rsa|id_ed25519|ssh keys?|private keys?|secret files?)\b[^.\n]{0,120}\b(?:to|into) https?:\/\//gi },
-    { label: "Data exfiltration instruction", regex: /\b(?:send|email|mail|forward|share|transmit|post|upload|exfiltrate|copy)\b[^.\n]{0,160}\b(?:api keys?|tokens?|secrets?|environment variables|\.env|credentials)\b[^.\n]{0,160}\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
-    { label: "Data exfiltration instruction", regex: /\b(?:send|email|mail|forward|share|transmit|post|upload|exfiltrate|copy)\b[^.\n]{0,160}(?:~\/\.ssh\/[A-Za-z0-9_.-]+|id_rsa|id_ed25519|ssh keys?|private keys?|secret files?)\b[^.\n]{0,160}\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
-    { label: "Data exfiltration instruction", regex: /(?:~\/\.ssh\/[A-Za-z0-9_.-]+|id_rsa|id_ed25519|ssh keys?|private keys?|secret files?|\bapi keys?|\btokens?|\bsecrets?|\benvironment variables|\.env|\bcredentials)\b[^.\n]{0,160}\b(?:send|email|mail|forward|share|transmit|post|upload|exfiltrate|copy)\b[^.\n]{0,120}\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
     { label: "Data exfiltration instruction", regex: /\b(?:curl|wget|fetch)\b[^\n]{0,160}\b(?:api keys?|tokens?|secrets?|environment variables|\.env|credentials)\b/gi },
-    { label: "Data exfiltration instruction", regex: /\b(?:curl|wget|fetch)\b[^\n]{0,160}(?:~\/\.ssh\/[A-Za-z0-9_.-]+|id_rsa|id_ed25519|ssh keys?|private keys?|secret files?)\b/gi },
     { label: "Credential harvesting instruction", regex: /\b(?:collect|harvest|steal|extract) (?:[^.\n]{0,80})\b(?:api keys?|tokens?|secrets?|environment variables|\.env|credentials)\b/gi },
-    { label: "Credential harvesting instruction", regex: /\b(?:collect|harvest|steal|extract)\b[^.\n]{0,120}(?:~\/\.ssh\/[A-Za-z0-9_.-]+|id_rsa|id_ed25519|ssh keys?|private keys?|secret files?)\b/gi },
 ];
 function redact(value) {
     if (value.length <= 12)
@@ -66,12 +46,6 @@ function pushFinding(findings, seen, label, line, value) {
     seen.add(key);
     findings.push({ label, line, preview: redact(value) });
 }
-function isPlaceholderValue(value) {
-    if (PLACEHOLDER_RE.test(value))
-        return true;
-    const words = value.toLowerCase().split(/[^a-z]+/).filter(Boolean);
-    return words.length >= 6 && words.every((word) => PLACEHOLDER_PHRASE_WORDS.has(word));
-}
 export function detectSecrets(input) {
     const findings = [];
     const seen = new Set();
@@ -85,14 +59,14 @@ export function detectSecrets(input) {
     GENERIC_ASSIGNMENT_RE.lastIndex = 0;
     for (const match of input.matchAll(GENERIC_ASSIGNMENT_RE)) {
         const value = match[1] ?? "";
-        if (!value || isPlaceholderValue(value))
+        if (!value || PLACEHOLDER_RE.test(value))
             continue;
         pushFinding(findings, seen, "Possible secret assignment", lineNumberAt(input, match.index ?? 0), value);
     }
     PROVIDER_LIKE_ASSIGNMENT_RE.lastIndex = 0;
     for (const match of input.matchAll(PROVIDER_LIKE_ASSIGNMENT_RE)) {
         const value = match[1] ?? "";
-        if (!value || isPlaceholderValue(value))
+        if (!value)
             continue;
         pushFinding(findings, seen, "Provider-like secret assignment", lineNumberAt(input, match.index ?? 0), value);
     }