@rhize/skill-forge 0.11.1 → 0.11.3

package/dist/cli.js

@@ -131,7 +131,32 @@ function collectNpxPackageSpecs(args) {
   }
   return { packageFlagSpecs, positionalSpec };
 }
+var ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+var PATH_SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
+function looksLikeFsPath(v) {
+  if (!/^(?:\/|~\/|\.\.?\/)/.test(v)) return false;
+  const segments = v.replace(/^~/, "").split("/").filter(Boolean);
+  return segments.length >= 2 && segments.every((seg) => PATH_SEGMENT_RE.test(seg));
+}
+function looksLikeBareUrl(v) {
+  let url;
+  try {
+    url = new URL(v);
+  } catch {
+    return false;
+  }
+  if (!["http:", "https:", "ws:", "wss:", "file:"].includes(url.protocol)) return false;
+  if (url.username !== "" || url.password !== "") return false;
+  if (url.search !== "") return false;
+  return true;
+}
+function looksStructuredNonSecret(value) {
+  const v = value.trim().replace(/^[[\s'"]+/, "").replace(/[\]\s'",]+$/, "");
+  if (v === "") return false;
+  return ISO_TIMESTAMP_RE.test(v) || looksLikeBareUrl(v) || looksLikeFsPath(v);
+}
 function looksHighEntropy(value) {
+  if (looksStructuredNonSecret(value)) return false;
   if (/\s/.test(value)) return false;
   if (value.length < 20) return false;
   const hasLower = /[a-z]/.test(value);
@@ -1024,6 +1049,37 @@ import { execFile } from "child_process";
 import { delimiter as delimiter2, join as join9 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+var RM_RF_TARGET_RE = /\brm\s+(?:-[a-z]+\s+)+("[^"]*"|'[^']*'|[^\s;|&)"'`]+)/i;
+function refineRmRf(line) {
+  const match = line.match(RM_RF_TARGET_RE);
+  if (!match) {
+    return { severity: "HIGH", message: "recursive force-delete (rm -rf) with an unparseable target \u2014 verify the path is scoped" };
+  }
+  const target = match[1].replace(/^["']|["']$/g, "").trim();
+  if (target.includes("$") || target.includes("`")) {
+    return {
+      severity: "HIGH",
+      message: `recursive force-delete of "${target}" \u2014 the target is a shell expansion; if it is empty or unset this can delete far more than intended`
+    };
+  }
+  if (target === "/" || target === "/*" || target === "*" || target === "." || target === ".." || target === "~" || target === "~/") {
+    return { severity: "HIGH", message: `recursive force-delete of "${target}" \u2014 this targets the filesystem root, the home directory, or everything in the working directory` };
+  }
+  if (target.startsWith("~")) {
+    return { severity: "HIGH", message: `recursive force-delete of "${target}" \u2014 targets a path inside the home directory, outside any project` };
+  }
+  if (target.split("/").includes("..")) {
+    return { severity: "HIGH", message: `recursive force-delete of "${target}" \u2014 the target escapes the current directory via ".."` };
+  }
+  if (target.startsWith("/")) {
+    const segments = target.split("/").filter(Boolean);
+    if (segments.length < 3) {
+      return { severity: "HIGH", message: `recursive force-delete of "${target}" \u2014 a shallow absolute path like this is a system directory` };
+    }
+    return { severity: "MEDIUM", message: `recursive force-delete of "${target}" \u2014 an absolute path outside any project directory` };
+  }
+  return null;
+}
 var DENY_RULES = [
   {
     rule: "curl-pipe-shell",
@@ -1047,7 +1103,8 @@ var DENY_RULES = [
     rule: "destructive-rm-rf",
     severity: "HIGH",
     pattern: /\brm\s+-[a-z]*r[a-z]*f[a-z]*\b|\brm\s+-[a-z]*f[a-z]*r[a-z]*\b/i,
-    message: "recursive force-delete (rm -rf) \u2014 verify the target path is scoped"
+    message: "recursive force-delete (rm -rf) \u2014 verify the target path is scoped",
+    refine: refineRmRf
   },
   {
     rule: "credential-file-access",
@@ -1102,11 +1159,13 @@ function scanStaticRules(targetPath) {
     for (const rule of DENY_RULES) {
       for (let i = 0; i < lines.length; i++) {
         if (rule.pattern.test(lines[i])) {
+          const refined = rule.refine ? rule.refine(lines[i]) : { severity: rule.severity, message: rule.message };
+          if (!refined) continue;
           findings.push({
-            severity: rule.severity,
+            severity: refined.severity,
             rule: rule.rule,
             file,
-            detail: `line ${i + 1}: ${rule.message}`
+            detail: `line ${i + 1}: ${refined.message}`
           });
         }
       }
@@ -1243,14 +1302,22 @@ function scanJsonConfig(file, parsed) {
     }
     if (node.env && typeof node.env === "object" && !Array.isArray(node.env)) {
       for (const [key, value] of Object.entries(node.env)) {
-        if (typeof value !== "string" || isPlaceholderValue(value)) continue;
-        if (looksCredentialKey(key) || looksHighEntropy(value)) {
+        if (typeof value !== "string") continue;
+        const kind = classifyCredentialAssignment(key, value);
+        if (kind === "inline-secret") {
           findings.push({
             severity: "HIGH",
             rule: "mcp-inline-credential-value",
             file,
             detail: `env.${key} has an inline credential value \u2014 emit an empty string and document that the user must fill it in`
           });
+        } else if (kind === "file-path") {
+          findings.push({
+            severity: "LOW",
+            rule: "mcp-credential-file-path",
+            file,
+            detail: `env.${key} points at a credential file rather than an inline secret \u2014 the value leaks nothing, but keep that file out of version control`
+          });
         }
       }
     }
@@ -1262,15 +1329,29 @@ var DANGEROUS_FLAG_RE = /--dangerously-[\w-]+|--no-sandbox\b/g;
 var CREDENTIAL_ASSIGNMENT_RE = /["']?([A-Za-z][A-Za-z0-9_]*)["']?\s*[:=]\s*["']([^"']{6,})["']/g;
 var CREDENTIAL_ASSIGNMENT_UNQUOTED_RE = /^\s*(?:export\s+|-\s+)?([A-Za-z][A-Za-z0-9_]*)\s*[:=]\s*(\S+)/;
 var LEADING_QUOTE_RE = /^["']/;
+function classifyCredentialAssignment(key, value) {
+  if (isPlaceholderValue(value)) return "none";
+  const credentialKey = looksCredentialKey(key);
+  if (credentialKey && looksStructuredNonSecret(value) && !/^[a-z]+:\/\//i.test(value.trim())) return "file-path";
+  if (credentialKey || looksHighEntropy(value)) return "inline-secret";
+  return "none";
+}
 function pushCredentialFinding(findings, file, lineNo, varName, value) {
-  if (isPlaceholderValue(value)) return;
-  if (looksCredentialKey(varName) || looksHighEntropy(value)) {
+  const kind = classifyCredentialAssignment(varName, value);
+  if (kind === "inline-secret") {
     findings.push({
       severity: "HIGH",
       rule: "mcp-inline-credential-value",
       file,
       detail: `line ${lineNo}: inline credential value assigned to ${varName}`
     });
+  } else if (kind === "file-path") {
+    findings.push({
+      severity: "LOW",
+      rule: "mcp-credential-file-path",
+      file,
+      detail: `line ${lineNo}: ${varName} points at a credential file rather than an inline secret \u2014 the value leaks nothing, but keep that file out of version control`
+    });
   }
 }
 function scanTextFile(file, content, allowCredentialCheck) {