@skaleagents/swarm 0.7.0 → 0.8.0

package/README.md

@@ -21,6 +21,10 @@ the MCP tool for a structured review.
 
 `npx -y @skaleagents/swarm scan [paths...]` scans IaC, CI, Dockerfile and package files on your machine. It needs no account and sends nothing over the network. Use `--changed` for files changed against HEAD, `--fail-on high` to exit 1, and `--json` for machine output.
 
+Adopt it on an existing repo: `npx @skaleagents/swarm scan --write-baseline .skaleagents-baseline.json`, commit the file, and later scans show only new findings. The Action reads the baseline from the PR's base commit, so a PR cannot hide findings by editing it. Findings match on rule, file and resource, not line number.
+
+`scan` also looks for committed secrets in any file it reads (AWS, GitHub, Slack, Stripe, Google, npm and Anthropic keys, private keys) as `SECRET001`, critical. The value is never printed. Git-ignored files such as a local `.env` are skipped. Rotate the key; only suppress a documented example.
+
 Suppress an intended setting with a comment on the flagged line or the line above: `# skaleagents-ignore DATA001 public asset bucket`.
 
 **Claude Code plugin.** It adds a stop hook that scans changed files and asks the agent to fix `high` and `critical` findings, plus a skill and the hosted MCP server:
@@ -33,7 +37,7 @@ Suppress an intended setting with a comment on the flagged line or the line abov
 **Cursor.** Add `.cursor/hooks.json`:
 
 ```json
-{ "version": 1, "hooks": { "stop": [{ "command": "npx -y --registry=https://registry.npmjs.org @skaleagents/swarm@0.7.0 scan --hook" }] } }
+{ "version": 1, "hooks": { "stop": [{ "command": "npx -y --registry=https://registry.npmjs.org @skaleagents/swarm@0.8.0 scan --hook" }] } }
 ```
 
 **GitHub Action.** It posts one PR comment and fails on `critical` by default:
@@ -47,7 +51,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with: { fetch-depth: 0 }
-      - uses: SkaleAgents/mcp-server@v0.7.0
+      - uses: SkaleAgents/mcp-server@v0.8.0
         with: { fail-on: high }
 ```
 

package/dist/cli.d.ts

@@ -8,5 +8,7 @@ export declare function scanFiles(files: string[], minSeverity?: FindingSeverity
     suppressed: number;
     warnings: string[];
 };
+export declare const baselineKey: (f: FileFinding) => string;
+export declare function readBaseline(path: string): Set<string>;
 export declare function formatText(findings: FileFinding[], suppressed: number): string;
 export declare function runScan(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -1,14 +1,17 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
 import { scanIac, severityRank } from "./iac/scan.js";
+import { scanSecrets } from "./secrets.js";
 const usage = `Usage: skaleagents-swarm scan [paths...] [options]
 
-Scans IaC, CI and package files locally. No account or network needed.
+Scans IaC, CI and package files, and any file for committed secrets, locally. No account or network needed.
 
   --changed              Scan files changed against HEAD plus untracked files
   --min-severity <s>     Hide findings below info|low|medium|high|critical (default low)
   --fail-on <s>          Exit 1 when a finding is at or above this severity
+  --baseline <file>      Hide findings already listed in this baseline file (.skaleagents-baseline.json is used automatically)
+  --write-baseline <file>  Write current findings to a baseline file and exit 0
   --json                 Print JSON instead of text
   --hook                 Agent stop hook mode for Claude Code and Cursor (implies --changed)
 
@@ -17,7 +20,7 @@ Suppress a finding with a comment on its line or the line above:
 const candidate = /\.(tf|tfvars|hcl|ya?ml|json|bicep)$|(^|[/\\])(Dockerfile|Containerfile)[^/\\]*$/;
 const skippedDirs = new Set([".git", "node_modules", "vendor", "dist", "build", ".terraform", ".next"]);
 const skippedFiles = /(^|[/\\])(package-lock\.json|tsconfig[^/\\]*\.json|composer\.lock|pnpm-lock\.yaml|yarn\.lock)$/;
-const maxFiles = 2000;
+const maxFiles = 20000;
 const severities = Object.keys(severityRank);
 function walk(path, out) {
     if (out.length >= maxFiles)
@@ -30,8 +33,7 @@ function walk(path, out) {
         return;
     }
     if (stat.isFile()) {
-        if (candidate.test(path) && !skippedFiles.test(path))
-            out.push(path);
+        out.push(path);
         return;
     }
     if (!stat.isDirectory())
@@ -46,6 +48,29 @@ function git(args) {
         .split("\0")
         .filter(Boolean);
 }
+// In a git repo, list tracked and untracked-but-not-ignored files so .gitignore keeps build output out of the count.
+function listFiles(paths, warnings) {
+    let files = [];
+    try {
+        files = git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...(paths.length ? paths : ["."])]).filter((file) => {
+            try {
+                return lstatSync(file).isFile();
+            }
+            catch {
+                return false; // Deleted in the working tree.
+            }
+        });
+    }
+    catch {
+        for (const path of paths.length ? paths : ["."])
+            walk(path, files);
+    }
+    if (files.length > maxFiles) {
+        warnings.push(`file limit reached: ${files.length - maxFiles} files not scanned`);
+        files = files.slice(0, maxFiles);
+    }
+    return files;
+}
 export function changedFiles() {
     let tracked = [];
     try {
@@ -91,6 +116,16 @@ export function scanFiles(files, minSeverity = "low") {
 }
 // Names come from scanned files, so they are flattened and capped before reaching an agent or PR comment.
 const clean = (value, max = 160) => (value ?? "").replace(/[\x00-\x1f\x7f`]+/g, " ").slice(0, max);
+// Line numbers are left out so unrelated edits above a finding do not make it look new.
+export const baselineKey = (f) => `${f.ruleId}|${f.file.replaceAll("\\", "/")}|${f.resource ?? ""}`;
+export function readBaseline(path) {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const keys = parsed?.findings;
+    if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
+        throw new Error(`${path} is not a SkaleAgents baseline file`);
+    }
+    return new Set(keys);
+}
 export function formatText(findings, suppressed) {
     if (findings.length === 0)
         return `SkaleAgents: no findings${suppressed ? ` (${suppressed} suppressed)` : ""}.`;
@@ -110,6 +145,8 @@ export async function runScan(argv) {
     let hook = false;
     let minSeverity = "low";
     let failOn;
+    let baselinePath;
+    let writeBaseline;
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         if (arg === "--") {
@@ -124,6 +161,15 @@ export async function runScan(argv) {
             hook = changed = true;
         else if (arg === "--min-severity")
             minSeverity = severityArg(argv[++i], arg);
+        else if (arg === "--baseline" || arg === "--write-baseline") {
+            const value = argv[++i];
+            if (!value)
+                throw new Error(`${arg} needs a file path`);
+            if (arg === "--baseline")
+                baselinePath = value;
+            else
+                writeBaseline = value;
+        }
         else if (arg === "--fail-on")
             failOn = severityArg(argv[++i], arg);
         else if (arg === "-h" || arg === "--help") {
@@ -142,14 +188,34 @@ export async function runScan(argv) {
             return 0;
         failOn ??= "high";
     }
+    const warnings = [];
     const files = [];
     if (changed) {
         for (const file of changedFiles())
             walk(file, files);
     }
-    for (const path of paths.length || changed ? paths : ["."])
-        walk(path, files);
-    const { findings, suppressed, warnings } = scanFiles([...new Set(files)], minSeverity);
+    if (paths.length || !changed)
+        files.push(...listFiles(paths, warnings));
+    if (files.length >= maxFiles)
+        warnings.push("file limit reached: some files were not scanned");
+    const unique = [...new Set(files)];
+    const scanned = scanFiles(unique.filter((file) => candidate.test(file) && !skippedFiles.test(file)), minSeverity);
+    const secrets = scanSecrets(unique);
+    scanned.findings = scanned.findings.concat(secrets.findings);
+    const suppressed = scanned.suppressed + secrets.suppressed;
+    warnings.push(...scanned.warnings);
+    if (secrets.truncated)
+        warnings.push("secret findings capped at 1000");
+    if (writeBaseline) {
+        const keys = [...new Set(scanned.findings.map(baselineKey))].sort();
+        writeFileSync(writeBaseline, `${JSON.stringify({ version: 1, findings: keys }, null, 2)}\n`);
+        console.log(`SkaleAgents: wrote ${keys.length} findings to ${writeBaseline}.`);
+        return 0;
+    }
+    // A committed baseline at the repo root applies automatically, so hooks and the Action need no flag.
+    baselinePath ??= existsSync(".skaleagents-baseline.json") ? ".skaleagents-baseline.json" : undefined;
+    const known = baselinePath ? readBaseline(baselinePath) : new Set();
+    const findings = scanned.findings.filter((f) => !known.has(baselineKey(f)));
     const failing = failOn ? findings.filter((f) => severityRank[f.severity] >= severityRank[failOn]) : [];
     if (hook) {
         if (failing.length) {

package/dist/iac/scan.d.ts

@@ -7,6 +7,10 @@ export type ScanOptions = {
     minSeverity?: FindingSeverity;
     maxFindings?: number;
 };
+export declare function applySuppressions(findings: Finding[], text: string): {
+    kept: Finding[];
+    suppressed: number;
+};
 export declare function summarize(findings: Finding[]): {
     critical: number;
     high: number;

package/dist/iac/scan.js

@@ -11,7 +11,7 @@ export const severityRank = {
 const markerLine = /^----- skaleagents-file: (.+) -----$/;
 const ignoreMarker = /skaleagents-ignore[ \t]+([A-Za-z0-9_, \t-]+)/;
 // A `skaleagents-ignore RULE[,RULE]` comment on the finding's line or the line above suppresses it.
-function applySuppressions(findings, text) {
+export function applySuppressions(findings, text) {
     const lines = text.split("\n");
     const ignored = (line, ruleId) => {
         if (!line || !ruleId)

package/dist/secrets.d.ts

@@ -0,0 +1,9 @@
+import type { Finding } from "./review.js";
+export type SecretFinding = Finding & {
+    file: string;
+};
+export declare function scanSecrets(files: string[]): {
+    findings: SecretFinding[];
+    suppressed: number;
+    truncated: boolean;
+};

package/dist/secrets.js

@@ -0,0 +1,101 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { relative } from "node:path";
+import { applySuppressions } from "./iac/scan.js";
+// High-confidence formats only: a false alarm on every high-entropy string would get the hook uninstalled.
+const patterns = [
+    ["AWS access key ID", /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g],
+    ["GitHub token", /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{50,})\b/g],
+    ["Slack token", /\bxox[abprs]-[A-Za-z0-9-]{10,}/g],
+    ["Stripe live key", /\b[sr]k_live_[A-Za-z0-9]{20,}\b/g],
+    ["Google API key", /\bAIza[0-9A-Za-z_-]{35}\b/g],
+    ["npm token", /\bnpm_[A-Za-z0-9]{36}\b/g],
+    ["Anthropic API key", /\bsk-ant-[A-Za-z0-9_-]{20,}/g],
+    ["Private key", /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY(?: BLOCK)?-----/g],
+];
+const maxBytes = 1_000_000;
+const maxFindings = 1000;
+const placeholder = /EXAMPLE|YOUR|PLACEHOLDER|XXXX/i;
+const skipped = /(^|[/\\])(package-lock\.json|composer\.lock|pnpm-lock\.yaml|yarn\.lock|\.skaleagents-baseline\.json)$|\.(png|jpe?g|gif|webp|ico|pdf|zip|gz|woff2?|ttf|mp4|mov|wasm|lock|map)$/i;
+function gitIgnored(files) {
+    try {
+        const out = execFileSync("git", ["check-ignore", "--stdin", "-z"], {
+            input: files.join("\0"),
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "ignore"],
+        });
+        return new Set(out.split("\0").filter(Boolean));
+    }
+    catch {
+        return new Set(); // Not a git repo, or nothing is ignored (exit 1).
+    }
+}
+// The matched text is never copied into a finding. A short digest keeps two keys in one file distinct.
+export function scanSecrets(files) {
+    const ignored = gitIgnored(files);
+    const findings = [];
+    let suppressed = 0;
+    for (const file of files) {
+        if (skipped.test(file) || ignored.has(file))
+            continue;
+        let text;
+        try {
+            if (statSync(file).size > maxBytes)
+                continue;
+            text = readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (text.includes("\0"))
+            continue;
+        const found = [];
+        const seen = new Set();
+        const lineStarts = [0];
+        for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1))
+            lineStarts.push(i + 1);
+        for (const [name, pattern] of patterns) {
+            for (const match of text.matchAll(pattern)) {
+                if (placeholder.test(match[0]))
+                    continue;
+                let low = 0;
+                let high = lineStarts.length - 1;
+                while (low < high) {
+                    const mid = (low + high + 1) >> 1;
+                    if (lineStarts[mid] <= match.index)
+                        low = mid;
+                    else
+                        high = mid - 1;
+                }
+                const line = low + 1;
+                // A key block's header is the same for every key, so its digest also covers the start of the body.
+                const material = name === "Private key" ? text.slice(match.index, match.index + match[0].length + 64) : match[0];
+                const digest = createHash("sha256").update(material).digest("hex").slice(0, 6);
+                const resource = `${name} ${digest}`;
+                found.push({
+                    severity: "critical",
+                    category: "security",
+                    ruleId: "SECRET001",
+                    title: `${name} in source`,
+                    detail: `A ${name.toLowerCase()} is committed in plain text. The value is not shown here.`,
+                    remediation: "Revoke and rotate it now, remove it from the file and from git history, and load it from a secret manager or environment variable.",
+                    resource,
+                    location: { line, column: 1, path: name },
+                });
+            }
+        }
+        const applied = applySuppressions(found, text);
+        suppressed += applied.suppressed;
+        for (const finding of applied.kept) {
+            // One finding per distinct secret per file, matching the baseline key, after suppressions so an ignored copy cannot hide another.
+            if (seen.has(finding.resource ?? ""))
+                continue;
+            seen.add(finding.resource ?? "");
+            if (findings.length >= maxFindings)
+                return { findings, suppressed, truncated: true };
+            findings.push({ ...finding, file: relative(".", file) });
+        }
+    }
+    return { findings, suppressed, truncated: false };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.7.0";
+export declare const VERSION = "0.8.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.7.0";
+export const VERSION = "0.8.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skaleagents/swarm",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -53,5 +53,6 @@
   "devDependencies": {
     "@types/node": "^22.20.1",
     "tsx": "^4.23.12"
-  }
+  },
+  "mcpName": "io.github.SkaleAgents/swarm"
 }