securevibe 0.1.3 → 0.1.7

package/README.md

@@ -70,10 +70,17 @@ Anything that fails the gate is rolled back and surfaced as a manual instruction
 - **Deterministic, offline (zero setup):** parameterize SQL (driver-aware placeholders),
   lock wildcard CORS to an env-driven allowlist, pin weak JWT algorithms, and move
   hardcoded secrets to env references / gitignore `.env`.
-- **Claude-powered (optional, set `ANTHROPIC_API_KEY`):** *targets* the logic-level classes a
-  rule can't safely rewrite — RCE/command-injection, AI tool-hijack / missing firewall, IDOR,
-  DOM XSS, and complex SQL. One rewrite per file; the result is kept **only if it passes the
-  verification gate**, otherwise it falls back to a precise manual instruction.
+- **AI-powered (optional, set `GROQ_API_KEY` for the free tier or `ANTHROPIC_API_KEY` for Claude):**
+  *targets* the logic-level classes a rule can't safely rewrite — RCE/command-injection, AI
+  tool-hijack / missing firewall, IDOR, DOM XSS, and complex SQL. One rewrite per file; the result
+  is kept **only if it passes the verification gate**, otherwise it falls back to a precise manual
+  instruction. Groq is used by default when both keys are present (lower bar to try it at all);
+  set `SECUREVIBE_LLM_PROVIDER=anthropic` to force Claude instead.
+- **Setting a key:** either export it yourself (`GROQ_API_KEY=...`), or run
+  `securevibe config set-key groq` — it prompts interactively (never as a command argument, so it
+  never lands in shell history) and saves it to `~/.securevibe/config.json`, used automatically by
+  `fix` whenever the env var isn't already set. Run `fix --apply` with no key configured and it will
+  offer to set one up on the spot. `securevibe config show` lists what's stored (masked).
 
 **Honesty (read this):**
 - A "fixed" finding means *our detector no longer flags it* — not that the app is proven secure.
@@ -82,9 +89,10 @@ Anything that fails the gate is rolled back and surfaced as a manual instruction
   *recognizes* (a tool allowlist + argument-schema validation — what the LLM prompt asks for).
   The prompt-injection surface typically remains (input still reaches the model) and is reported
   as a residual to address with input isolation.
-- The deterministic, offline fixers are verified end-to-end here. The **live Claude path is wired
-  and unit-tested (response parsing, gate behavior) but has not been exercised against a real API
-  key in this build** — set `ANTHROPIC_API_KEY` and review the diffs it proposes.
+- The deterministic, offline fixers are verified end-to-end here. The **AI-powered path (Groq or
+  Claude) is wired and unit-tested (provider selection, response parsing, the truncation and
+  verification gates) but has not been exercised against a real API key in this build** — set
+  `GROQ_API_KEY` or `ANTHROPIC_API_KEY` and review the diffs it proposes.
 - `fix` is **dry-run by default**; `--apply` backs up originals to `.securevibe-backup/<ts>/` first.
 - `fix --apply` is **interactive**: it shows each verified diff and asks `[y]es / [n]o / [a]ll / [q]uit`
   before writing. A declined change is reported `skipped`, never `fixed`, and the after-score reflects

package/dist/config.js

@@ -0,0 +1,78 @@
+/**
+ * Local provider-key storage for the optional AI-powered fixer (doc 05). An
+ * explicit shell env var (GROQ_API_KEY / ANTHROPIC_API_KEY) always wins over
+ * whatever is stored here — this file only supplies a default when neither is
+ * already set, so `fix` doesn't require re-exporting a key every session.
+ *
+ * Storage note (be precise, not reassuring): this is a plain JSON file under
+ * the user's home directory. On macOS/Linux we set file mode 0600 (owner
+ * read/write only). On Windows, Node cannot restrict file ACLs by owner/group
+ * (the group/owner/other distinction isn't implemented there — only the
+ * read-only bit is), so the real protection on Windows is that the file lives
+ * under the user's own profile directory, which the OS already scopes to that
+ * account — not the file mode.
+ */
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const KEY_FIELD = {
+    groq: "groqApiKey",
+    anthropic: "anthropicApiKey",
+};
+const ENV_VAR = {
+    groq: "GROQ_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+};
+export function configDir() {
+    return path.join(os.homedir(), ".securevibe");
+}
+export function configFilePath() {
+    return path.join(configDir(), "config.json");
+}
+/** Tolerant read: a missing or corrupt file is treated as an empty config. */
+export async function readConfig(file = configFilePath()) {
+    try {
+        const raw = await fs.readFile(file, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeConfig(patch, file = configFilePath()) {
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+    const current = await readConfig(file);
+    const next = { ...current, ...patch };
+    await fs.writeFile(file, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+export async function setKey(provider, key, file) {
+    await writeConfig({ [KEY_FIELD[provider]]: key }, file);
+}
+export async function unsetKey(provider, file = configFilePath()) {
+    const current = await readConfig(file);
+    delete current[KEY_FIELD[provider]];
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(file, JSON.stringify(current, null, 2) + "\n", { mode: 0o600 });
+}
+/**
+ * Copy any stored key into process.env, but only for a provider whose env var
+ * isn't already set — an explicit shell export always takes precedence over
+ * what's on disk. Call once at the start of a command that may need a key.
+ */
+export async function applyStoredKeysToEnv(file = configFilePath()) {
+    const cfg = await readConfig(file);
+    if (cfg.groqApiKey && !process.env.GROQ_API_KEY)
+        process.env.GROQ_API_KEY = cfg.groqApiKey;
+    if (cfg.anthropicApiKey && !process.env.ANTHROPIC_API_KEY)
+        process.env.ANTHROPIC_API_KEY = cfg.anthropicApiKey;
+}
+/** Masked display form: first 6 chars + last 4, for showing "is a key configured" without leaking it. */
+export function maskKey(key) {
+    if (key.length <= 10)
+        return "*".repeat(key.length);
+    return `${key.slice(0, 6)}${"*".repeat(Math.max(4, key.length - 10))}${key.slice(-4)}`;
+}
+export { ENV_VAR };

package/dist/engine/detectors/classic.js

@@ -350,6 +350,249 @@ const insecureConfig = (ctx) => {
     }
     return out;
 };
+/**
+ * Insecure deserialization. `yaml.load` without an explicit safe loader
+ * deserializes arbitrary Python objects from the document — flagged
+ * unconditionally (there is no safe use of the bare form). `pickle.loads` /
+ * `marshal.loads` are only dangerous when fed untrusted bytes, so those are
+ * taint-gated.
+ */
+const YAML_LOAD_RE = /\byaml\.load\s*\(/;
+const YAML_SAFE_LOADER_RE = /Loader\s*=\s*(yaml\.)?(SafeLoader|CSafeLoader|FullLoader)\b|yaml\.safe_load\b/;
+const insecureDeserialization = (ctx) => {
+    const out = [];
+    if (ctx.file.lang === "python") {
+        const code = codeWithoutComments(ctx.root, ctx.file.code);
+        if (YAML_LOAD_RE.test(code) && !YAML_SAFE_LOADER_RE.test(code)) {
+            out.push(mkFinding(ctx, {
+                line: lineNumberOf(code, YAML_LOAD_RE),
+                detector: "insecure-deserialization",
+                title: "Insecure deserialization: yaml.load without a safe loader",
+                category: "classic",
+                severity: "critical",
+                confidence: 0.85,
+                reachable: true,
+                cwe: "CWE-502",
+                owasp: "A08:2021 Software and Data Integrity Failures",
+                why: "yaml.load() with the default (or Loader=yaml.Loader) can construct arbitrary Python objects from the document, letting an attacker who controls the YAML achieve code execution.",
+                fix: "Use yaml.safe_load() or pass Loader=yaml.SafeLoader explicitly.",
+            }));
+        }
+    }
+    walk(ctx.root, (n) => {
+        if (!isCall(n))
+            return;
+        const callee = calleeText(n) ?? "";
+        const isPickle = /^pickle\.(loads?|Unpickler)\b/.test(callee);
+        const isMarshal = /^marshal\.loads?\b/.test(callee);
+        const isNodeSerialize = /^(serialize|node-serialize)\.unserialize\b/.test(callee) || callee === "unserialize";
+        if (!isPickle && !isMarshal && !isNodeSerialize)
+            return;
+        const args = argsText(n);
+        const tainted = isTainted(args, ctx.taint) || isUntrustedStringBuild(args, ctx.taint);
+        if (!tainted)
+            return;
+        out.push(mkFinding(ctx, {
+            node: n,
+            detector: "insecure-deserialization",
+            title: `Insecure deserialization: untrusted data reaches ${callee}()`,
+            category: "classic",
+            severity: "critical",
+            confidence: 0.85,
+            reachable: true,
+            cwe: "CWE-502",
+            owasp: "A08:2021 Software and Data Integrity Failures",
+            why: "Deserializing untrusted bytes with pickle/marshal/node-serialize can execute arbitrary code embedded in the payload during deserialization.",
+            fix: "Never deserialize untrusted data with pickle/marshal/node-serialize. Use a data-only format (JSON) or sign/verify the payload before deserializing.",
+            taint: ["request input", `→ ${callee}()`],
+        }));
+    });
+    return out;
+};
+/** Open redirect: untrusted input controls a server-issued redirect target. */
+const REDIRECT_CALLEE_RE = /(^|\.)redirect$/;
+const openRedirect = (ctx) => {
+    const out = [];
+    walk(ctx.root, (n) => {
+        if (!isCall(n))
+            return;
+        const callee = calleeText(n) ?? "";
+        if (!REDIRECT_CALLEE_RE.test(callee))
+            return;
+        const argsNode = n.childForFieldName("arguments");
+        const firstArg = argsNode?.namedChild(0)?.text ?? "";
+        if (!firstArg)
+            return;
+        if (!isTainted(firstArg, ctx.taint) && !isUntrustedStringBuild(firstArg, ctx.taint))
+            return;
+        out.push(mkFinding(ctx, {
+            node: n,
+            detector: "open-redirect",
+            title: "Open redirect: untrusted input controls the redirect target",
+            category: "classic",
+            severity: "medium",
+            confidence: 0.7,
+            reachable: true,
+            cwe: "CWE-601",
+            owasp: "A01:2021 Broken Access Control",
+            why: "A request-controlled value is used as a redirect target. An attacker can craft a link on your domain that redirects victims to a phishing site.",
+            fix: "Validate the redirect target against an allowlist of known paths/hosts, or only allow relative paths within your own app.",
+            taint: ["request input", "→ redirect target", `→ ${callee}()`],
+        }));
+    });
+    return out;
+};
+/** Server-side template injection: untrusted input becomes template source, not just data. */
+// Bare `Template(...)` is excluded: Python's stdlib string.Template is safe
+// substitution with no code execution, and callee text alone can't
+// distinguish it from a Jinja2 Template — only jinja2.Template is unambiguous.
+const SSTI_CALLEE_RE = /^(render_template_string|jinja2\.Template)\b/;
+const ssti = (ctx) => {
+    const out = [];
+    walk(ctx.root, (n) => {
+        if (!isCall(n))
+            return;
+        const callee = calleeText(n) ?? "";
+        if (!SSTI_CALLEE_RE.test(callee))
+            return;
+        const argsNode = n.childForFieldName("arguments");
+        const firstArg = argsNode?.namedChild(0)?.text ?? "";
+        if (!firstArg)
+            return;
+        if (!isTainted(firstArg, ctx.taint) && !isUntrustedStringBuild(firstArg, ctx.taint))
+            return;
+        out.push(mkFinding(ctx, {
+            node: n,
+            detector: "ssti",
+            title: "Server-side template injection: untrusted input used as template source",
+            category: "classic",
+            severity: "critical",
+            confidence: 0.8,
+            reachable: true,
+            cwe: "CWE-1336",
+            owasp: "A03:2021 Injection",
+            mitre: "T1190",
+            why: "Untrusted input is compiled as a template (not just passed as data into one), letting an attacker inject template syntax that executes on the server.",
+            fix: "Never build a template string from user input. Pass untrusted data as render context/variables into a fixed template, not as the template source itself.",
+            taint: ["request input", "→ template source", `→ ${callee}()`],
+        }));
+    });
+    return out;
+};
+/**
+ * NoSQL injection: untrusted input used directly as (or inside) a Mongo-style
+ * query filter/operator object, allowing operator injection (e.g. {$ne: null}).
+ */
+const MONGO_QUERY_CALLEE_RE = /\.(find|findOne|findOneAndUpdate|findOneAndDelete|updateOne|updateMany|deleteOne|deleteMany|count|countDocuments)$/;
+const MONGO_OPERATOR_RE = /\$where|\$ne|\$gt|\$regex/;
+const nosqlInjection = (ctx) => {
+    const out = [];
+    walk(ctx.root, (n) => {
+        if (!isCall(n))
+            return;
+        const callee = calleeText(n) ?? "";
+        if (!MONGO_QUERY_CALLEE_RE.test(callee))
+            return;
+        const argsNode = n.childForFieldName("arguments");
+        const firstArg = argsNode?.namedChild(0) ?? null;
+        if (!firstArg || firstArg.type !== "object")
+            return; // only a literal filter object is analyzable
+        const filterText = firstArg.text;
+        // The whole request object/body passed straight through as the filter
+        // (e.g. find(req.body) or find({...req.query})) is the classic operator-
+        // injection pattern; a tainted scalar bound to a known key is normal use.
+        const wholeObjectTaint = isTainted(filterText, ctx.taint) && /\.\.\.|(^\{\s*req\b)/.test(filterText);
+        const operatorTaint = MONGO_OPERATOR_RE.test(filterText) && isTainted(filterText, ctx.taint);
+        if (!wholeObjectTaint && !operatorTaint)
+            return;
+        out.push(mkFinding(ctx, {
+            node: n,
+            detector: "nosql-injection",
+            title: "NoSQL injection: untrusted input builds the query filter object",
+            category: "classic",
+            severity: "critical",
+            confidence: 0.75,
+            reachable: true,
+            cwe: "CWE-943",
+            owasp: "A03:2021 Injection",
+            why: "Untrusted input is spread or forwarded directly into a MongoDB filter object. An attacker can inject operators like $ne/$gt/$where to bypass query logic (e.g. authentication) or run arbitrary JavaScript.",
+            fix: "Never pass a raw request object as a query filter. Pick out and validate individual fields, and reject values that are objects when a scalar is expected.",
+            taint: ["request input", "→ query filter object", `→ ${callee}()`],
+        }));
+    });
+    return out;
+};
+/**
+ * Weak crypto / insecure randomness in a security-sensitive context. AST-driven
+ * (matches a genuine call node, never text inside a string/comment/fixture) and
+ * scoped to calls whose enclosing statement mentions token/password/secret/
+ * session/auth vocabulary, so ordinary Math.random()/md5 use (UI ids, cache
+ * keys, checksums) isn't flagged.
+ */
+const SECURITY_CONTEXT_RE = /token|password|passwd|secret|session|apikey|api_key|otp|auth/i;
+const STATEMENT_TYPES = new Set([
+    "variable_declarator", "assignment_expression", "assignment", "expression_statement",
+    "return_statement", "pair", "property", "keyword_argument", "dictionary",
+]);
+/** Nearest enclosing statement-ish node text, for judging security context around a call. */
+function enclosingStatementText(n) {
+    let cur = n.parent;
+    for (let i = 0; i < 8 && cur; i++) {
+        if (STATEMENT_TYPES.has(cur.type))
+            return cur.text;
+        cur = cur.parent;
+    }
+    return n.parent?.text ?? n.text;
+}
+const weakCrypto = (ctx) => {
+    const out = [];
+    walk(ctx.root, (n) => {
+        if (!isCall(n))
+            return;
+        const callee = calleeText(n) ?? "";
+        if (callee === "Math.random") {
+            const context = enclosingStatementText(n);
+            if (!SECURITY_CONTEXT_RE.test(context))
+                return;
+            out.push(mkFinding(ctx, {
+                node: n,
+                detector: "weak-crypto",
+                title: "Insecure randomness: Math.random() used for a security-sensitive value",
+                category: "classic",
+                severity: "high",
+                confidence: 0.6,
+                reachable: true,
+                cwe: "CWE-330",
+                owasp: "A02:2021 Cryptographic Failures",
+                why: "Math.random() is not cryptographically secure and is predictable. Using it for tokens, passwords, or session identifiers lets an attacker guess or brute-force them.",
+                fix: "Use a CSPRNG: crypto.randomBytes()/crypto.randomUUID() (Node) or the secrets module (Python).",
+            }));
+            return;
+        }
+        const firstArgText = n.childForFieldName("arguments")?.namedChild(0)?.text ?? "";
+        const isWeakHashCall = (/\bcreateHash$/.test(callee) && /^["'](md5|sha1)["']$/i.test(firstArgText)) ||
+            /^hashlib\.(md5|sha1)$/i.test(callee);
+        if (isWeakHashCall) {
+            const context = enclosingStatementText(n);
+            if (!SECURITY_CONTEXT_RE.test(context))
+                return;
+            out.push(mkFinding(ctx, {
+                node: n,
+                detector: "weak-crypto",
+                title: "Weak hash algorithm used for a security-sensitive value",
+                category: "classic",
+                severity: "high",
+                confidence: 0.6,
+                reachable: true,
+                cwe: "CWE-327",
+                owasp: "A02:2021 Cryptographic Failures",
+                why: "MD5 and SHA1 are broken for security purposes (collision attacks, fast brute force) and unsuitable for hashing passwords or secrets.",
+                fix: "Use a password hashing function (bcrypt/argon2/scrypt) for passwords, or SHA-256+ for integrity checks.",
+            }));
+        }
+    });
+    return out;
+};
 function lineNumberOf(code, re) {
     const idx = code.search(re);
     if (idx < 0)
@@ -364,4 +607,9 @@ export const classicDetectors = [
     xss,
     brokenAccessControl,
     insecureConfig,
+    insecureDeserialization,
+    openRedirect,
+    ssti,
+    nosqlInjection,
+    weakCrypto,
 ];

package/dist/engine/fix/llm.js

@@ -11,18 +11,52 @@ export const LLM_DETECTORS = new Set([
     "broken-access-control",
     "sql-injection", // the shapes the deterministic fixer declined
 ]);
-/** Files larger than this are left to manual review (a single rewrite gets unreliable). */
+/**
+ * Files larger than this are left to manual review (a single rewrite gets
+ * unreliable). Kept well under the 8192-token output cap below — a full-file
+ * rewrite needs roughly as many output tokens as the input has, plus room for
+ * the added fix — so this cap must stay smaller than max_tokens would allow.
+ */
 const MAX_FILE_CHARS = 16_000;
-export function defaultModel() {
-    return process.env.SECUREVIBE_MODEL || "claude-sonnet-4-6";
+const DEFAULT_MODEL = {
+    groq: "llama-3.3-70b-versatile",
+    anthropic: "claude-sonnet-4-6",
+};
+const KEY_ENV = {
+    groq: "GROQ_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+};
+/**
+ * Which provider to use, if any: an explicit SECUREVIBE_LLM_PROVIDER wins (only
+ * if its key is present); else Groq when GROQ_API_KEY is set (the free-tier
+ * default); else Anthropic when ANTHROPIC_API_KEY is set; else none.
+ */
+function selectProvider() {
+    const forced = process.env.SECUREVIBE_LLM_PROVIDER?.toLowerCase();
+    if (forced === "groq" || forced === "anthropic") {
+        return process.env[KEY_ENV[forced]] ? forced : null;
+    }
+    if (process.env.GROQ_API_KEY)
+        return "groq";
+    if (process.env.ANTHROPIC_API_KEY)
+        return "anthropic";
+    return null;
+}
+function modelFor(provider) {
+    return process.env.SECUREVIBE_MODEL || DEFAULT_MODEL[provider];
 }
 export function llmAvailability(disabled) {
-    const model = defaultModel();
     if (disabled)
-        return { available: false, reason: "disabled (--no-llm)", model };
-    if (!process.env.ANTHROPIC_API_KEY)
-        return { available: false, reason: "no ANTHROPIC_API_KEY", model };
-    return { available: true, model };
+        return { available: false, reason: "disabled (--no-llm)", model: "" };
+    const provider = selectProvider();
+    if (!provider) {
+        const forced = process.env.SECUREVIBE_LLM_PROVIDER?.toLowerCase();
+        const reason = forced === "groq" || forced === "anthropic"
+            ? `SECUREVIBE_LLM_PROVIDER=${forced} but ${KEY_ENV[forced]} is not set`
+            : "no GROQ_API_KEY or ANTHROPIC_API_KEY";
+        return { available: false, reason, model: "" };
+    }
+    return { available: true, provider, model: modelFor(provider) };
 }
 const SYSTEM = [
     "You are a senior application-security engineer fixing vulnerabilities in source code.",
@@ -40,23 +74,11 @@ const SYSTEM = [
     "...full file...",
     "</file>",
 ].join("\n");
-/** Returns the corrected file content, or null if unavailable / declined / unreliable. */
-export async function llmFix(input) {
-    if (!process.env.ANTHROPIC_API_KEY)
-        return null;
-    if (input.code.length > MAX_FILE_CHARS)
-        return null;
-    let Anthropic;
-    try {
-        ({ default: Anthropic } = await import("@anthropic-ai/sdk"));
-    }
-    catch {
-        return null; // SDK not installed → graceful fallback
-    }
+function userPrompt(input) {
     const findingList = input.findings
         .map((f, i) => `${i + 1}. [${f.severity}] ${f.detector} at line ${f.line}: ${f.title}\n   Why: ${f.why}\n   Intended fix: ${f.fix}`)
         .join("\n");
-    const user = [
+    return [
         `File: ${input.relPath} (${input.lang})`,
         "",
         "Findings to fix:",
@@ -67,29 +89,73 @@ export async function llmFix(input) {
         input.code,
         "</file>",
     ].join("\n");
+}
+/** Returns the corrected file content, or null if unavailable / declined / unreliable. */
+export async function llmFix(input) {
+    if (input.code.length > MAX_FILE_CHARS)
+        return null;
+    const provider = selectProvider();
+    if (!provider)
+        return null;
     try {
-        const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
-        const msg = await client.messages.create({
-            model: defaultModel(),
-            max_tokens: 4096,
-            system: SYSTEM,
-            messages: [{ role: "user", content: user }],
-        });
-        const text = extractText(msg);
+        const text = provider === "groq" ? await callGroq(input) : await callAnthropic(input);
         return parseFile(text, input.code);
     }
     catch {
         return null; // network / auth / quota failure → fall back to manual
     }
 }
+async function callAnthropic(input) {
+    let Anthropic;
+    try {
+        ({ default: Anthropic } = await import("@anthropic-ai/sdk"));
+    }
+    catch {
+        throw new Error("SDK not installed");
+    }
+    const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    const msg = await client.messages.create({
+        model: modelFor("anthropic"),
+        max_tokens: 8192,
+        system: SYSTEM,
+        messages: [{ role: "user", content: userPrompt(input) }],
+    });
+    return extractAnthropicText(msg);
+}
+/** Groq's chat-completions endpoint is OpenAI-compatible — plain fetch, no SDK. */
+async function callGroq(input) {
+    const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${process.env.GROQ_API_KEY}`,
+        },
+        body: JSON.stringify({
+            model: modelFor("groq"),
+            max_tokens: 8192,
+            messages: [
+                { role: "system", content: SYSTEM },
+                { role: "user", content: userPrompt(input) },
+            ],
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`Groq API error: ${res.status}`);
+    const json = await res.json();
+    return extractGroqText(json);
+}
 /** Exported for unit testing the response plumbing without a live API call. */
-export function extractText(msg) {
+export function extractAnthropicText(msg) {
     const blocks = Array.isArray(msg?.content) ? msg.content : [];
     return blocks
         .filter((b) => b?.type === "text" && typeof b.text === "string")
         .map((b) => b.text)
         .join("");
 }
+/** Exported for unit testing the response plumbing without a live API call. */
+export function extractGroqText(json) {
+    return json?.choices?.[0]?.message?.content ?? "";
+}
 /**
  * Pull the rewritten file out of the response and sanity-check it. We reject a
  * result that is suspiciously short relative to the original (likely truncated),

package/dist/engine/fix/session.js

@@ -97,7 +97,7 @@ export async function runFix(root, options = {}) {
             if (outcomes.some((o) => o.finding.id === f.id))
                 continue;
             const note = LLM_DETECTORS.has(f.detector) && !llm.available
-                ? `Needs an AI-assisted fix — set ANTHROPIC_API_KEY to auto-fix (currently ${llm.reason}). Manual: ${oneLine(f.fix)}`
+                ? `Needs an AI-assisted fix — set GROQ_API_KEY (free tier) or ANTHROPIC_API_KEY to auto-fix (currently ${llm.reason}). Manual: ${oneLine(f.fix)}`
                 : `No safe automatic fix for this class yet. Manual: ${oneLine(f.fix)}`;
             outcomes.push(manual(f, note));
         }
@@ -136,6 +136,7 @@ export async function runFix(root, options = {}) {
         root: absRoot,
         apply: !!options.apply,
         llmAvailable: llm.available,
+        llmProvider: llm.provider,
         scoreBefore: before.score,
         scoreAfter,
         outcomes: sortOutcomes(outcomes),

package/dist/engine/readiness/scorecard.js

@@ -1,7 +1,7 @@
 const GATES = [
     { id: "secrets", label: "Secrets managed", detectors: ["hardcoded-secret"], crit: "blocker" },
     { id: "deps", label: "Dependencies current", detectors: ["vulnerable-dependency"], crit: "critical-only" },
-    { id: "injection", label: "Injection safe (SQLi/RCE/SSRF)", detectors: ["sql-injection", "code-execution", "path-traversal", "ssrf"], crit: "blocker" },
+    { id: "injection", label: "Injection safe (SQLi/RCE/SSRF/SSTI/NoSQL)", detectors: ["sql-injection", "code-execution", "path-traversal", "ssrf", "ssti", "nosql-injection", "insecure-deserialization"], crit: "blocker" },
     { id: "authz", label: "Access control", detectors: ["broken-access-control"], crit: "blocker" },
     { id: "ai", label: "AI agent safety", detectors: ["ai-tool-hijack", "ai-missing-firewall", "ai-prompt-injection", "ai-overprivileged-tool"], crit: "high-blocks" },
     { id: "transport", label: "Transport config (CORS/JWT)", detectors: ["cors-misconfig", "weak-jwt"], crit: "warning" },

package/dist/index.js

@@ -92,6 +92,34 @@ async function maybeNotifyUpdate(opts) {
     if (latest)
         process.stderr.write("\n" + updateNotice(VERSION, latest) + "\n");
 }
+/**
+ * If `fix` is about to run with no AI-fixer provider key available (and we're
+ * in an interactive terminal), offer to set one up on the spot — a free Groq
+ * key takes under a minute. Never prompts under --json/non-TTY/--no-llm, and
+ * never touches process.env if the user declines or a key is already set.
+ */
+async function maybeOfferAiFixerSetup() {
+    if (process.env.GROQ_API_KEY || process.env.ANTHROPIC_API_KEY)
+        return;
+    const { isInteractive, askLine } = await import("./ui/prompt.js");
+    if (!isInteractive())
+        return;
+    process.stderr.write("\n  AI auto-fix (RCE, AI tool-hijack, IDOR, complex SQLi) needs a provider key — you don't have one set.\n");
+    const ans = (await askLine("  Enable it now with a free Groq key? [y/N]: ")).trim().toLowerCase();
+    if (ans !== "y" && ans !== "yes") {
+        process.stderr.write("  Skipping — those findings will show as manual review. Run `securevibe config set-key groq` anytime.\n\n");
+        return;
+    }
+    const key = (await askLine("  Paste your Groq key (get one free at console.groq.com/keys): ")).trim();
+    if (!key) {
+        process.stderr.write("  No key entered — skipping.\n\n");
+        return;
+    }
+    const { setKey, configFilePath } = await import("./config.js");
+    await setKey("groq", key);
+    process.env.GROQ_API_KEY = key;
+    process.stderr.write(`  Saved to ${configFilePath()}. This run will use it.\n\n`);
+}
 /** Exit code policy for CI gating (doc 08/12). */
 function ciExit(result, opts) {
     if (!opts.ci)
@@ -135,17 +163,23 @@ program
     .argument("[path]", "path to the repository", ".")
     .option("--apply", "write the fixes to disk (asks before each change unless --yes)")
     .option("--yes", "apply every verified fix without prompting (for CI / scripts)")
-    .option("--no-llm", "disable the optional Claude-powered fixer")
+    .option("--no-llm", "disable the optional AI-powered fixer (Groq or Claude)")
     .option("--json", "output machine-readable JSON")
     .option("--no-color", "disable coloured output")
     .action(async (pathArg, opts) => {
     if (opts.color === false)
         process.env.NO_COLOR = "1";
-    await meter();
-    const { runFix } = await import("./engine/fix/session.js");
+    const { applyStoredKeysToEnv } = await import("./config.js");
+    await applyStoredKeysToEnv();
     const { isInteractive, decideApply, makeFixConfirm } = await import("./ui/prompt.js");
-    const { renderFixSession, fixToJson, renderApprovalRequest } = await import("./ui/fix.js");
     const decision = decideApply(opts, isInteractive());
+    // Only worth asking on a run that will actually write something — a dry-run
+    // preview has no use for a key yet, and asking anyway reads as nagging.
+    if (opts.llm !== false && !opts.json && decision.apply)
+        await maybeOfferAiFixerSetup();
+    const usage = await meter();
+    const { runFix } = await import("./engine/fix/session.js");
+    const { renderFixSession, fixToJson, renderApprovalRequest } = await import("./ui/fix.js");
     const result = await runFix(pathArg ?? ".", {
         apply: decision.apply,
         noLlm: opts.llm === false,
@@ -155,7 +189,7 @@ program
     if (opts.json)
         process.stdout.write(fixToJson(result) + "\n");
     else
-        process.stdout.write(renderFixSession(result) + "\n");
+        process.stdout.write(renderFixSession(result, usage) + "\n");
     if (decision.notice) {
         process.stderr.write("  Not applied: no interactive terminal. Re-run with --yes to apply non-interactively.\n");
     }
@@ -267,6 +301,57 @@ program
     process.stderr.write(`  unknown db action: ${action} (use: update | status)\n`);
     process.exit(64);
 });
+program
+    .command("config")
+    .description("Manage local AI-fixer provider keys (Groq/Anthropic), stored in ~/.securevibe/config.json")
+    .argument("<action>", "show | set-key | unset-key")
+    .argument("[provider]", "groq | anthropic")
+    .option("--no-color", "disable coloured output")
+    .action(async (action, provider, opts) => {
+    if (opts.color === false)
+        process.env.NO_COLOR = "1";
+    const { readConfig, setKey, unsetKey, maskKey, configFilePath, ENV_VAR } = await import("./config.js");
+    const { isInteractive, askLine } = await import("./ui/prompt.js");
+    if (action === "show") {
+        const cfg = await readConfig();
+        const line = (label, stored, envSet) => `  ${label}:`.padEnd(13) +
+            (stored ? maskKey(stored) : "not set") +
+            (envSet ? "  (env var active, overrides the stored key)" : "");
+        process.stdout.write("  SecureVibe AI-fixer keys\n");
+        process.stdout.write(`  file: ${configFilePath()}\n`);
+        process.stdout.write(line("groq", cfg.groqApiKey, !!process.env.GROQ_API_KEY) + "\n");
+        process.stdout.write(line("anthropic", cfg.anthropicApiKey, !!process.env.ANTHROPIC_API_KEY) + "\n");
+        return;
+    }
+    if (action === "set-key" || action === "unset-key") {
+        if (provider !== "groq" && provider !== "anthropic") {
+            process.stderr.write(`  usage: securevibe config ${action} <groq|anthropic>\n`);
+            process.exit(64);
+        }
+    }
+    if (action === "set-key") {
+        if (!isInteractive()) {
+            process.stderr.write("  set-key needs an interactive terminal — a key is never accepted as a command argument, to keep it out of shell history.\n");
+            process.exit(64);
+        }
+        const hint = provider === "groq" ? " (free — get one at console.groq.com/keys)" : " (from console.anthropic.com)";
+        const key = (await askLine(`  Paste your ${provider} API key${hint}: `)).trim();
+        if (!key) {
+            process.stderr.write("  No key entered — nothing saved.\n");
+            process.exit(1);
+        }
+        await setKey(provider, key);
+        process.stdout.write(`  Saved to ${configFilePath()}. Used automatically by \`fix\` whenever ${ENV_VAR[provider]} isn't already set in your shell.\n`);
+        return;
+    }
+    if (action === "unset-key") {
+        await unsetKey(provider);
+        process.stdout.write(`  Removed the stored ${provider} key.\n`);
+        return;
+    }
+    process.stderr.write(`  unknown config action: ${action} (use: show | set-key | unset-key)\n`);
+    process.exit(64);
+});
 program.parseAsync(process.argv).catch((err) => {
     process.stderr.write(`securevibe: ${err?.message ?? err}\n`);
     process.exit(70);

package/dist/ui/fix.js

@@ -7,6 +7,7 @@
 import pc from "picocolors";
 import { structuredPatch } from "diff";
 import { renderBanner } from "./banner.js";
+import { renderUsageLine } from "./usage.js";
 const SEV_TAG = {
     critical: (s) => pc.bgRed(pc.white(pc.bold(s))),
     high: (s) => pc.red(pc.bold(s)),
@@ -31,10 +32,14 @@ function readinessLabel(r) {
 function scoreBadge(s) {
     return `${gradeColor(s.grade)(pc.bold(` ${s.grade} `))} ${s.composite}/100 ${readinessLabel(s.readiness)}`;
 }
-export function renderFixSession(result) {
+export function renderFixSession(result, usage) {
     const L = [];
     L.push(renderBanner({ subtitle: result.apply ? "fix · applying" : "fix · dry run (no files changed)" }));
     L.push("");
+    if (usage) {
+        L.push(renderUsageLine(usage));
+        L.push("");
+    }
     // Score transition.
     L.push("  " + scoreBadge(result.scoreBefore) + pc.dim("  →  ") + scoreBadge(result.scoreAfter));
     L.push("");
@@ -50,8 +55,10 @@ export function renderFixSession(result) {
     if (skipped.length > 0)
         counts.push(pc.dim(`${skipped.length} skipped`));
     counts.push(pc.yellow(`${manual.length} need manual review`));
-    L.push("  " + counts.join("  ·  ") +
-        (result.llmAvailable ? pc.dim("  ·  Claude fixer: on") : pc.dim("  ·  Claude fixer: off")));
+    const aiFixerLabel = result.llmAvailable
+        ? `AI fixer: on (${result.llmProvider === "groq" ? "Groq" : "Claude"})`
+        : "AI fixer: off";
+    L.push("  " + counts.join("  ·  ") + pc.dim(`  ·  ${aiFixerLabel}`));
     L.push("");
     // Diffs for accepted patches.
     for (const p of result.patches) {
@@ -107,7 +114,7 @@ export function renderFixSession(result) {
     L.push(pc.dim("  These fixes mean the detector no longer flags the issue — not that the app is proven secure. " +
         "Review every diff and run your tests before deploying."));
     if (!result.llmAvailable && result.outcomes.some((o) => o.status === "manual")) {
-        L.push(pc.dim("  Set ANTHROPIC_API_KEY to auto-fix logic-level issues (RCE, AI tool hijack, IDOR)."));
+        L.push(pc.dim("  Set GROQ_API_KEY (free tier) or ANTHROPIC_API_KEY to auto-fix logic-level issues (RCE, AI tool hijack, IDOR)."));
     }
     L.push("");
     return L.join("\n");

package/dist/version.js

@@ -2,4 +2,4 @@
 // Single source of truth for the CLI's own version, so it can't drift from
 // what commander reports and what the update-check compares against.
 // Kept in sync with the "version" field in package.json by hand at release time.
-export const VERSION = "0.1.3";
+export const VERSION = "0.1.7";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securevibe",
-  "version": "0.1.3",
+  "version": "0.1.7",
   "description": "Autonomous AI security engineer for AI generated apps: scan, fix, verify, and gate every commit before you launch",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",