@ai-dossier/core 1.3.0 → 1.3.2

package/dist/security-scanner/code-block-context.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Utilities for detecting whether content appears inside fenced code blocks.
+ *
+ * Findings inside code blocks are downgraded in confidence because the content
+ * is illustrative/documentary rather than executable instructions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodeBlockRanges = parseCodeBlockRanges;
+exports.isLineInCodeBlock = isLineInCodeBlock;
+exports.getLineNumber = getLineNumber;
+/**
+ * Parse all fenced code block ranges from a markdown body.
+ * Supports ``` and ~~~ fences per CommonMark spec.
+ */
+function parseCodeBlockRanges(body) {
+    const lines = body.split('\n');
+    const ranges = [];
+    let openFenceLine = null;
+    let openFenceChar = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trimStart();
+        // Check for opening or closing fence
+        const backtickMatch = trimmed.match(/^(`{3,})/);
+        const tildeMatch = trimmed.match(/^(~{3,})/);
+        const fenceMatch = backtickMatch || tildeMatch;
+        if (fenceMatch) {
+            const fenceChar = backtickMatch ? '`' : '~';
+            const fenceLen = fenceMatch[1].length;
+            if (openFenceLine === null) {
+                // Opening a new code block
+                openFenceLine = i + 1; // 1-based
+                openFenceChar = fenceChar;
+            }
+            else if (fenceChar === openFenceChar && fenceLen >= 3) {
+                // Closing the current code block (must use same fence character)
+                ranges.push({ startLine: openFenceLine, endLine: i + 1 });
+                openFenceLine = null;
+                openFenceChar = null;
+            }
+        }
+    }
+    // If a fence was never closed, treat everything from the opening to EOF as a code block
+    if (openFenceLine !== null) {
+        ranges.push({ startLine: openFenceLine, endLine: lines.length });
+    }
+    return ranges;
+}
+/**
+ * Check whether a given 1-based line number falls inside any fenced code block.
+ */
+function isLineInCodeBlock(line, ranges) {
+    return ranges.some((r) => line >= r.startLine && line <= r.endLine);
+}
+/**
+ * Get the 1-based line number for a character offset in a string.
+ */
+function getLineNumber(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text[i] === '\n') {
+            line++;
+        }
+    }
+    return line;
+}
+//# sourceMappingURL=code-block-context.js.map

package/dist/security-scanner/code-block-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block-context.js","sourceRoot":"","sources":["../../src/security-scanner/code-block-context.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAWH,oDAsCC;AAKD,8CAEC;AAKD,sCAQC;AA9DD;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,IAAY;IAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,IAAI,aAAa,GAAkB,IAAI,CAAC;IACxC,IAAI,aAAa,GAAkB,IAAI,CAAC;IAExC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAEjC,qCAAqC;QACrC,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7C,MAAM,UAAU,GAAG,aAAa,IAAI,UAAU,CAAC;QAE/C,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;YAC5C,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;YAEtC,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;gBAC3B,2BAA2B;gBAC3B,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU;gBACjC,aAAa,GAAG,SAAS,CAAC;YAC5B,CAAC;iBAAM,IAAI,SAAS,KAAK,aAAa,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;gBACxD,iEAAiE;gBACjE,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC1D,aAAa,GAAG,IAAI,CAAC;gBACrB,aAAa,GAAG,IAAI,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAED,wFAAwF;IACxF,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB,CAAC,IAAY,EAAE,MAAwB;IACtE,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,SAAS,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;AACtE,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAAC,IAAY,EAAE,MAAc;IACxD,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnD,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YACrB,IAAI,EAAE,CAAC;QACT,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/security-scanner/index.d.ts

@@ -0,0 +1,21 @@
+import type { SecurityReport, SecurityScanConfig } from './types';
+export { buildReport, SecurityRuleRegistry } from './registry';
+export { agentHijackingRule, dangerousExecutionRule, dataExfiltrationRule, defaultSecurityRules, promptInjectionRule, supplyChainRule, unicodeAttacksRule, urlThreatsRule, xssHtmlInjectionRule, } from './rules';
+export * from './types';
+/**
+ * Scan a dossier's markdown body for security threats.
+ *
+ * Accepts raw dossier content (frontmatter + body) as a string.
+ */
+export declare function scanDossier(content: string, config?: SecurityScanConfig): SecurityReport;
+/**
+ * Scan a dossier file at the given path for security threats.
+ */
+export declare function scanDossierFile(filePath: string, config?: SecurityScanConfig): SecurityReport;
+/**
+ * Scan raw markdown text (without dossier frontmatter) for security threats.
+ *
+ * Useful for scanning arbitrary markdown files that are not dossiers.
+ */
+export declare function scanMarkdown(markdown: string, config?: SecurityScanConfig): SecurityReport;
+//# sourceMappingURL=index.d.ts.map

package/dist/security-scanner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/security-scanner/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAuB,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEvF,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,MAAM,SAAS,CAAC;AACjB,cAAc,SAAS,CAAC;AAUxB;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,cAAc,CAaxF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,cAAc,CAa7F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,cAAc,CAY1F"}

package/dist/security-scanner/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xssHtmlInjectionRule = exports.urlThreatsRule = exports.unicodeAttacksRule = exports.supplyChainRule = exports.promptInjectionRule = exports.defaultSecurityRules = exports.dataExfiltrationRule = exports.dangerousExecutionRule = exports.agentHijackingRule = exports.SecurityRuleRegistry = exports.buildReport = void 0;
+exports.scanDossier = scanDossier;
+exports.scanDossierFile = scanDossierFile;
+exports.scanMarkdown = scanMarkdown;
+const parser_1 = require("../parser");
+const registry_1 = require("./registry");
+const rules_1 = require("./rules");
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "buildReport", { enumerable: true, get: function () { return registry_2.buildReport; } });
+Object.defineProperty(exports, "SecurityRuleRegistry", { enumerable: true, get: function () { return registry_2.SecurityRuleRegistry; } });
+var rules_2 = require("./rules");
+Object.defineProperty(exports, "agentHijackingRule", { enumerable: true, get: function () { return rules_2.agentHijackingRule; } });
+Object.defineProperty(exports, "dangerousExecutionRule", { enumerable: true, get: function () { return rules_2.dangerousExecutionRule; } });
+Object.defineProperty(exports, "dataExfiltrationRule", { enumerable: true, get: function () { return rules_2.dataExfiltrationRule; } });
+Object.defineProperty(exports, "defaultSecurityRules", { enumerable: true, get: function () { return rules_2.defaultSecurityRules; } });
+Object.defineProperty(exports, "promptInjectionRule", { enumerable: true, get: function () { return rules_2.promptInjectionRule; } });
+Object.defineProperty(exports, "supplyChainRule", { enumerable: true, get: function () { return rules_2.supplyChainRule; } });
+Object.defineProperty(exports, "unicodeAttacksRule", { enumerable: true, get: function () { return rules_2.unicodeAttacksRule; } });
+Object.defineProperty(exports, "urlThreatsRule", { enumerable: true, get: function () { return rules_2.urlThreatsRule; } });
+Object.defineProperty(exports, "xssHtmlInjectionRule", { enumerable: true, get: function () { return rules_2.xssHtmlInjectionRule; } });
+__exportStar(require("./types"), exports);
+const defaultConfig = { rules: {} };
+function createRegistry() {
+    const registry = new registry_1.SecurityRuleRegistry();
+    registry.registerAll(rules_1.defaultSecurityRules);
+    return registry;
+}
+/**
+ * Scan a dossier's markdown body for security threats.
+ *
+ * Accepts raw dossier content (frontmatter + body) as a string.
+ */
+function scanDossier(content, config) {
+    const parsed = (0, parser_1.parseDossierContent)(content);
+    const resolvedConfig = config ?? defaultConfig;
+    const registry = createRegistry();
+    const context = {
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        raw: parsed.raw,
+    };
+    const findings = registry.run(context, resolvedConfig);
+    return (0, registry_1.buildReport)(findings);
+}
+/**
+ * Scan a dossier file at the given path for security threats.
+ */
+function scanDossierFile(filePath, config) {
+    const parsed = (0, parser_1.parseDossierFile)(filePath);
+    const resolvedConfig = config ?? defaultConfig;
+    const registry = createRegistry();
+    const context = {
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        raw: parsed.raw,
+    };
+    const findings = registry.run(context, resolvedConfig);
+    return (0, registry_1.buildReport)(findings, filePath);
+}
+/**
+ * Scan raw markdown text (without dossier frontmatter) for security threats.
+ *
+ * Useful for scanning arbitrary markdown files that are not dossiers.
+ */
+function scanMarkdown(markdown, config) {
+    const resolvedConfig = config ?? defaultConfig;
+    const registry = createRegistry();
+    const context = {
+        frontmatter: {},
+        body: markdown,
+        raw: markdown,
+    };
+    const findings = registry.run(context, resolvedConfig);
+    return (0, registry_1.buildReport)(findings);
+}
+//# sourceMappingURL=index.js.map

package/dist/security-scanner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/security-scanner/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAgCA,kCAaC;AAKD,0CAaC;AAOD,oCAYC;AAlFD,sCAAkE;AAClE,yCAA+D;AAC/D,mCAA+C;AAG/C,uCAA+D;AAAtD,uGAAA,WAAW,OAAA;AAAE,gHAAA,oBAAoB,OAAA;AAC1C,iCAUiB;AATf,2GAAA,kBAAkB,OAAA;AAClB,+GAAA,sBAAsB,OAAA;AACtB,6GAAA,oBAAoB,OAAA;AACpB,6GAAA,oBAAoB,OAAA;AACpB,4GAAA,mBAAmB,OAAA;AACnB,wGAAA,eAAe,OAAA;AACf,2GAAA,kBAAkB,OAAA;AAClB,uGAAA,cAAc,OAAA;AACd,6GAAA,oBAAoB,OAAA;AAEtB,0CAAwB;AAExB,MAAM,aAAa,GAAuB,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;AAExD,SAAS,cAAc;IACrB,MAAM,QAAQ,GAAG,IAAI,+BAAoB,EAAE,CAAC;IAC5C,QAAQ,CAAC,WAAW,CAAC,4BAAoB,CAAC,CAAC;IAC3C,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,SAAgB,WAAW,CAAC,OAAe,EAAE,MAA2B;IACtE,MAAM,MAAM,GAAG,IAAA,4BAAmB,EAAC,OAAO,CAAC,CAAC;IAC5C,MAAM,cAAc,GAAG,MAAM,IAAI,aAAa,CAAC;IAC/C,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC;IAElC,MAAM,OAAO,GAAwB;QACnC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,GAAG,EAAE,MAAM,CAAC,GAAG;KAChB,CAAC;IAEF,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACvD,OAAO,IAAA,sBAAW,EAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,QAAgB,EAAE,MAA2B;IAC3E,MAAM,MAAM,GAAG,IAAA,yBAAgB,EAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,cAAc,GAAG,MAAM,IAAI,aAAa,CAAC;IAC/C,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC;IAElC,MAAM,OAAO,GAAwB;QACnC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,GAAG,EAAE,MAAM,CAAC,GAAG;KAChB,CAAC;IAEF,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACvD,OAAO,IAAA,sBAAW,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,QAAgB,EAAE,MAA2B;IACxE,MAAM,cAAc,GAAG,MAAM,IAAI,aAAa,CAAC;IAC/C,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC;IAElC,MAAM,OAAO,GAAwB;QACnC,WAAW,EAAE,EAAwC;QACrD,IAAI,EAAE,QAAQ;QACd,GAAG,EAAE,QAAQ;KACd,CAAC;IAEF,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACvD,OAAO,IAAA,sBAAW,EAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC"}

package/dist/security-scanner/match-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared regex matching utility for security rules.
+ *
+ * Avoids the `noAssignInExpressions` lint violation by using
+ * `matchAll` instead of a `while (match = exec())` loop.
+ */
+import { type CodeBlockRange } from './code-block-context';
+import type { SecurityCategory, SecurityFinding, SecuritySeverity } from './types';
+export interface PatternDefinition {
+    pattern: RegExp;
+    description: string;
+}
+export interface PatternWithSeverity extends PatternDefinition {
+    severity: SecuritySeverity;
+}
+/**
+ * Run a global regex against text and collect all matches as SecurityFindings.
+ * Uses `String.matchAll` to avoid assignment-in-expression.
+ */
+export declare function matchPattern(text: string, pattern: RegExp, codeBlockRanges: CodeBlockRange[], ruleId: string, category: SecurityCategory, description: string, defaultSeverity: SecuritySeverity, codeBlockSeverity?: SecuritySeverity): SecurityFinding[];
+//# sourceMappingURL=match-utils.d.ts.map

package/dist/security-scanner/match-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-utils.d.ts","sourceRoot":"","sources":["../../src/security-scanner/match-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAoC,MAAM,sBAAsB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEnF,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,cAAc,EAAE,EACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,gBAAgB,EACjC,iBAAiB,GAAE,gBAAyB,GAC3C,eAAe,EAAE,CAsBnB"}

package/dist/security-scanner/match-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Shared regex matching utility for security rules.
+ *
+ * Avoids the `noAssignInExpressions` lint violation by using
+ * `matchAll` instead of a `while (match = exec())` loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPattern = matchPattern;
+const code_block_context_1 = require("./code-block-context");
+/**
+ * Run a global regex against text and collect all matches as SecurityFindings.
+ * Uses `String.matchAll` to avoid assignment-in-expression.
+ */
+function matchPattern(text, pattern, codeBlockRanges, ruleId, category, description, defaultSeverity, codeBlockSeverity = 'info') {
+    const findings = [];
+    // Ensure the regex has the global flag for matchAll
+    const globalPattern = pattern.global ? pattern : new RegExp(pattern.source, `${pattern.flags}g`);
+    for (const match of text.matchAll(globalPattern)) {
+        const line = (0, code_block_context_1.getLineNumber)(text, match.index ?? 0);
+        const inCodeBlock = (0, code_block_context_1.isLineInCodeBlock)(line, codeBlockRanges);
+        findings.push({
+            ruleId,
+            category,
+            severity: inCodeBlock ? codeBlockSeverity : defaultSeverity,
+            message: `${formatCategory(category)}: ${description}`,
+            evidence: match[0].slice(0, 200),
+            line,
+            inCodeBlock,
+        });
+    }
+    return findings;
+}
+function formatCategory(category) {
+    return category
+        .split('-')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+//# sourceMappingURL=match-utils.js.map

package/dist/security-scanner/match-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-utils.js","sourceRoot":"","sources":["../../src/security-scanner/match-utils.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAkBH,oCA+BC;AA/CD,6DAA6F;AAY7F;;;GAGG;AACH,SAAgB,YAAY,CAC1B,IAAY,EACZ,OAAe,EACf,eAAiC,EACjC,MAAc,EACd,QAA0B,EAC1B,WAAmB,EACnB,eAAiC,EACjC,oBAAsC,MAAM;IAE5C,MAAM,QAAQ,GAAsB,EAAE,CAAC;IAEvC,oDAAoD;IACpD,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;IAEjG,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,GAAG,IAAA,kCAAa,EAAC,IAAI,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;QACnD,MAAM,WAAW,GAAG,IAAA,sCAAiB,EAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAE7D,QAAQ,CAAC,IAAI,CAAC;YACZ,MAAM;YACN,QAAQ;YACR,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,eAAe;YAC3D,OAAO,EAAE,GAAG,cAAc,CAAC,QAAQ,CAAC,KAAK,WAAW,EAAE;YACtD,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;YAChC,IAAI;YACJ,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,cAAc,CAAC,QAA0B;IAChD,OAAO,QAAQ;SACZ,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAClD,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC"}

package/dist/security-scanner/registry.d.ts

@@ -0,0 +1,11 @@
+import type { SecurityFinding, SecurityReport, SecurityRule, SecurityRuleContext, SecurityScanConfig } from './types';
+export declare class SecurityRuleRegistry {
+    private rules;
+    register(rule: SecurityRule): void;
+    registerAll(rules: SecurityRule[]): void;
+    getRules(): SecurityRule[];
+    getRule(id: string): SecurityRule | undefined;
+    run(context: SecurityRuleContext, config: SecurityScanConfig): SecurityFinding[];
+}
+export declare function buildReport(findings: SecurityFinding[], file?: string): SecurityReport;
+//# sourceMappingURL=registry.d.ts.map

package/dist/security-scanner/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/security-scanner/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,mBAAmB,EAEnB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAUjB,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAwC;IAErD,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAIlC,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAMxC,QAAQ,IAAI,YAAY,EAAE;IAI1B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI7C,GAAG,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,kBAAkB,GAAG,eAAe,EAAE;CAgCjF;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc,CAwBtF"}

package/dist/security-scanner/registry.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityRuleRegistry = void 0;
+exports.buildReport = buildReport;
+const SEVERITY_ORDER = {
+    critical: 4,
+    high: 3,
+    medium: 2,
+    low: 1,
+    info: 0,
+};
+class SecurityRuleRegistry {
+    rules = new Map();
+    register(rule) {
+        this.rules.set(rule.id, rule);
+    }
+    registerAll(rules) {
+        for (const rule of rules) {
+            this.register(rule);
+        }
+    }
+    getRules() {
+        return Array.from(this.rules.values());
+    }
+    getRule(id) {
+        return this.rules.get(id);
+    }
+    run(context, config) {
+        const findings = [];
+        const minSeverityLevel = SEVERITY_ORDER[config.minSeverity ?? 'info'];
+        for (const rule of this.rules.values()) {
+            const override = config.rules[rule.id];
+            if (override === 'off') {
+                continue;
+            }
+            const severity = override
+                ? override
+                : rule.defaultSeverity;
+            if (SEVERITY_ORDER[severity] < minSeverityLevel) {
+                continue;
+            }
+            const ruleFindings = rule.detect(context);
+            for (const f of ruleFindings) {
+                // Respect the code-block downgrade: if the rule already lowered the
+                // severity for an in-code-block finding, keep that lower severity
+                // rather than overriding it with the config/default level.
+                const effectiveSeverity = f.inCodeBlock ? f.severity : severity;
+                findings.push({ ...f, severity: effectiveSeverity });
+            }
+        }
+        return findings;
+    }
+}
+exports.SecurityRuleRegistry = SecurityRuleRegistry;
+function buildReport(findings, file) {
+    const criticalCount = findings.filter((f) => f.severity === 'critical').length;
+    const highCount = findings.filter((f) => f.severity === 'high').length;
+    const mediumCount = findings.filter((f) => f.severity === 'medium').length;
+    const lowCount = findings.filter((f) => f.severity === 'low').length;
+    const infoCount = findings.filter((f) => f.severity === 'info').length;
+    let verdict = 'PASS';
+    if (criticalCount > 0 || highCount > 0) {
+        verdict = 'FAIL';
+    }
+    else if (mediumCount > 0) {
+        verdict = 'WARN';
+    }
+    return {
+        file,
+        findings,
+        criticalCount,
+        highCount,
+        mediumCount,
+        lowCount,
+        infoCount,
+        verdict,
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/security-scanner/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/security-scanner/registry.ts"],"names":[],"mappings":"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"}

package/dist/security-scanner/rules/agent-hijacking.d.ts

@@ -0,0 +1,3 @@
+import type { SecurityRule } from '../types';
+export declare const agentHijackingRule: SecurityRule;
+//# sourceMappingURL=agent-hijacking.d.ts.map

package/dist/security-scanner/rules/agent-hijacking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-hijacking.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/agent-hijacking.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AA2C9D,eAAO,MAAM,kBAAkB,EAAE,YA0BhC,CAAC"}

package/dist/security-scanner/rules/agent-hijacking.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentHijackingRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns that attempt to hijack agent behavior — overriding system instructions,
+ * granting autonomy, or suppressing safety checks.
+ */
+const AGENT_HIJACKING_PATTERNS = [
+    // Attempts to override system instructions
+    {
+        pattern: /(?:new|updated|revised|real)\s+system\s+(?:prompt|instructions?|message|directive)/gi,
+        description: 'Attempt to inject new system instructions',
+    },
+    // Granting unrestricted autonomy
+    {
+        pattern: /(?:you\s+(?:have|are\s+granted|now\s+have)\s+)?(?:full|unrestricted|unlimited|complete)\s+(?:access|autonomy|control|permissions?|authority)/gi,
+        description: 'Attempt to grant unrestricted autonomy/permissions',
+    },
+    // Suppressing safety checks
+    {
+        pattern: /(?:skip|bypass|disable|ignore|turn\s+off|suppress)\s+(?:safety|security|verification|validation|approval|confirmation|checks?|guards?|filters?)/gi,
+        description: 'Attempt to suppress safety/security checks',
+    },
+    // Role reassignment
+    {
+        pattern: /(?:act\s+as|pretend\s+(?:to\s+be|you(?:'re| are))|roleplay\s+as|switch\s+(?:to|into)\s+(?:a\s+)?(?:root|admin|superuser|developer|DAN|jailbr))/gi,
+        description: 'Role reassignment / jailbreak attempt',
+    },
+    // "Do anything now" (DAN) style jailbreaks
+    {
+        pattern: /\bDAN\s+(?:mode|prompt|jailbreak)\b|do\s+anything\s+now/gi,
+        description: 'DAN-style jailbreak pattern',
+    },
+    // Instruction to not follow rules
+    {
+        pattern: /(?:don'?t|do\s+not|never)\s+(?:follow|obey|adhere\s+to|comply\s+with)\s+(?:the\s+)?(?:rules?|guidelines?|policies?|restrictions?|constraints?)/gi,
+        description: 'Instruction to not follow rules/guidelines',
+    },
+];
+exports.agentHijackingRule = {
+    id: 'agent-hijacking',
+    category: 'agent-hijacking',
+    description: 'Detects attempts to hijack agent behavior — system instruction overrides and autonomy escalation',
+    defaultSeverity: 'critical',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of AGENT_HIJACKING_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'agent-hijacking', 'agent-hijacking', description, 'critical'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=agent-hijacking.js.map

package/dist/security-scanner/rules/agent-hijacking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-hijacking.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/agent-hijacking.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;GAGG;AACH,MAAM,wBAAwB,GAA+C;IAC3E,2CAA2C;IAC3C;QACE,OAAO,EAAE,sFAAsF;QAC/F,WAAW,EAAE,2CAA2C;KACzD;IACD,iCAAiC;IACjC;QACE,OAAO,EACL,gJAAgJ;QAClJ,WAAW,EAAE,oDAAoD;KAClE;IACD,4BAA4B;IAC5B;QACE,OAAO,EACL,mJAAmJ;QACrJ,WAAW,EAAE,4CAA4C;KAC1D;IACD,oBAAoB;IACpB;QACE,OAAO,EACL,kJAAkJ;QACpJ,WAAW,EAAE,uCAAuC;KACrD;IACD,2CAA2C;IAC3C;QACE,OAAO,EAAE,2DAA2D;QACpE,WAAW,EAAE,6BAA6B;KAC3C;IACD,kCAAkC;IAClC;QACE,OAAO,EACL,kJAAkJ;QACpJ,WAAW,EAAE,4CAA4C;KAC1D;CACF,CAAC;AAEW,QAAA,kBAAkB,GAAiB;IAC9C,EAAE,EAAE,iBAAiB;IACrB,QAAQ,EAAE,iBAAiB;IAC3B,WAAW,EACT,kGAAkG;IACpG,eAAe,EAAE,UAAU;IAC3B,MAAM,CAAC,OAAO;QACZ,MAAM,QAAQ,GAAsB,EAAE,CAAC;QACvC,MAAM,eAAe,GAAG,IAAA,yCAAoB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3D,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,wBAAwB,EAAE,CAAC;YAChE,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,UAAU,CACX,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/dangerous-execution.d.ts

@@ -0,0 +1,3 @@
+import type { SecurityRule } from '../types';
+export declare const dangerousExecutionRule: SecurityRule;
+//# sourceMappingURL=dangerous-execution.d.ts.map

package/dist/security-scanner/rules/dangerous-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dangerous-execution.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/dangerous-execution.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AAuE9D,eAAO,MAAM,sBAAsB,EAAE,YA0BpC,CAAC"}

package/dist/security-scanner/rules/dangerous-execution.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dangerousExecutionRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns for dangerous shell commands and code execution.
+ * These detect actual commands that could be destructive or facilitate code injection.
+ */
+const DANGEROUS_EXECUTION_PATTERNS = [
+    // Recursive force removal
+    {
+        pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\b|\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\b/g,
+        description: 'Recursive force delete (rm -rf)',
+    },
+    // Pipe to shell — curl/wget piped to bash/sh
+    {
+        pattern: /(?:curl|wget)\s+[^\n|]*\|\s*(?:ba)?sh\b|(?:curl|wget)\s+[^\n|]*\|\s*(?:sudo\s+)?(?:ba)?sh/g,
+        description: 'Remote script execution (curl/wget piped to shell)',
+    },
+    // eval with variable/dynamic content
+    {
+        pattern: /\beval\s*\(\s*["`$]|\beval\s+["'`$]/g,
+        description: 'Dynamic eval execution',
+    },
+    // chmod 777 (world-writable)
+    {
+        pattern: /\bchmod\s+777\b/g,
+        description: 'Setting world-writable permissions (chmod 777)',
+    },
+    // dd writing to block devices
+    {
+        pattern: /\bdd\s+.*\bof\s*=\s*\/dev\//g,
+        description: 'Direct block device write (dd of=/dev/...)',
+    },
+    // mkfs (format filesystem)
+    {
+        pattern: /\bmkfs\b/g,
+        description: 'Filesystem format command (mkfs)',
+    },
+    // Fork bomb patterns
+    {
+        pattern: /:\(\)\s*\{\s*:\|:\s*&\s*\}\s*;?\s*:/g,
+        description: 'Fork bomb',
+    },
+    // Python/Node one-liner execution
+    {
+        pattern: /python[23]?\s+-c\s+['"].*(?:exec|eval|import\s+os|subprocess|__import__)/g,
+        description: 'Python one-liner with dangerous imports/execution',
+    },
+    // Encoded/obfuscated command execution
+    {
+        pattern: /\bbase64\s+-d\b.*\|\s*(?:ba)?sh/g,
+        description: 'Base64-decoded payload piped to shell',
+    },
+    // Overwriting critical system files
+    {
+        pattern: />\s*\/etc\/(?:passwd|shadow|sudoers|hosts|crontab)/g,
+        description: 'Overwriting critical system file',
+    },
+    // Reverse shell patterns
+    {
+        pattern: /\bbash\s+-i\s+>&?\s*\/dev\/tcp\/|\bnc\s+.*-e\s+\/bin\/(?:ba)?sh|\bsocat\b.*\bexec\b.*\/bin\/(?:ba)?sh/g,
+        description: 'Reverse shell pattern',
+    },
+    // crontab injection
+    {
+        pattern: /(?:echo|printf)\s+.*\|\s*crontab/g,
+        description: 'Crontab injection via pipe',
+    },
+];
+exports.dangerousExecutionRule = {
+    id: 'dangerous-execution',
+    category: 'dangerous-execution',
+    description: 'Detects dangerous shell commands — rm -rf, curl|sh, eval, reverse shells, etc.',
+    defaultSeverity: 'high',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of DANGEROUS_EXECUTION_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'dangerous-execution', 'dangerous-execution', description, 'high', 'low'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=dangerous-execution.js.map

package/dist/security-scanner/rules/dangerous-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dangerous-execution.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/dangerous-execution.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;GAGG;AACH,MAAM,4BAA4B,GAA+C;IAC/E,0BAA0B;IAC1B;QACE,OAAO,EAAE,kFAAkF;QAC3F,WAAW,EAAE,iCAAiC;KAC/C;IACD,6CAA6C;IAC7C;QACE,OAAO,EACL,4FAA4F;QAC9F,WAAW,EAAE,oDAAoD;KAClE;IACD,qCAAqC;IACrC;QACE,OAAO,EAAE,sCAAsC;QAC/C,WAAW,EAAE,wBAAwB;KACtC;IACD,6BAA6B;IAC7B;QACE,OAAO,EAAE,kBAAkB;QAC3B,WAAW,EAAE,gDAAgD;KAC9D;IACD,8BAA8B;IAC9B;QACE,OAAO,EAAE,8BAA8B;QACvC,WAAW,EAAE,4CAA4C;KAC1D;IACD,2BAA2B;IAC3B;QACE,OAAO,EAAE,WAAW;QACpB,WAAW,EAAE,kCAAkC;KAChD;IACD,qBAAqB;IACrB;QACE,OAAO,EAAE,sCAAsC;QAC/C,WAAW,EAAE,WAAW;KACzB;IACD,kCAAkC;IAClC;QACE,OAAO,EAAE,2EAA2E;QACpF,WAAW,EAAE,mDAAmD;KACjE;IACD,uCAAuC;IACvC;QACE,OAAO,EAAE,kCAAkC;QAC3C,WAAW,EAAE,uCAAuC;KACrD;IACD,oCAAoC;IACpC;QACE,OAAO,EAAE,qDAAqD;QAC9D,WAAW,EAAE,kCAAkC;KAChD;IACD,yBAAyB;IACzB;QACE,OAAO,EACL,wGAAwG;QAC1G,WAAW,EAAE,uBAAuB;KACrC;IACD,oBAAoB;IACpB;QACE,OAAO,EAAE,mCAAmC;QAC5C,WAAW,EAAE,4BAA4B;KAC1C;CACF,CAAC;AAEW,QAAA,sBAAsB,GAAiB;IAClD,EAAE,EAAE,qBAAqB;IACzB,QAAQ,EAAE,qBAAqB;IAC/B,WAAW,EAAE,gFAAgF;IAC7F,eAAe,EAAE,MAAM;IACvB,MAAM,CAAC,OAAO;QACZ,MAAM,QAAQ,GAAsB,EAAE,CAAC;QACvC,MAAM,eAAe,GAAG,IAAA,yCAAoB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3D,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,4BAA4B,EAAE,CAAC;YACpE,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,WAAW,EACX,MAAM,EACN,KAAK,CACN,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/data-exfiltration.d.ts

@@ -0,0 +1,3 @@
+import type { SecurityRule } from '../types';
+export declare const dataExfiltrationRule: SecurityRule;
+//# sourceMappingURL=data-exfiltration.d.ts.map

package/dist/security-scanner/rules/data-exfiltration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-exfiltration.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/data-exfiltration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AAgD9D,eAAO,MAAM,oBAAoB,EAAE,YA0BlC,CAAC"}

package/dist/security-scanner/rules/data-exfiltration.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataExfiltrationRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns that indicate data exfiltration — sending data to external URLs
+ * via image tags, tracking pixels, DNS exfil, or webhook-based exfil.
+ */
+const DATA_EXFILTRATION_PATTERNS = [
+    // Markdown image with dynamic/parameterized URL (data in query string)
+    {
+        pattern: /!\[[^\]]*\]\(https?:\/\/[^)]*(?:\$\{|`[^`]*`|\{\{)[^)]*\)/g,
+        description: 'Markdown image with dynamic/templated URL (potential data exfiltration)',
+    },
+    // HTML image with suspicious query parameters suggesting data exfil
+    {
+        pattern: /<img[^>]+src\s*=\s*["']https?:\/\/[^"']*(?:data=|exfil=|payload=|token=|secret=|key=|password=|env=)[^"']*["']/gi,
+        description: 'HTML image tag with data exfiltration query parameters',
+    },
+    // 1x1 tracking pixel (common exfil technique)
+    {
+        pattern: /<img[^>]+(?:width\s*=\s*["']1["'][^>]*height\s*=\s*["']1["']|height\s*=\s*["']1["'][^>]*width\s*=\s*["']1["'])/gi,
+        description: 'Tracking pixel (1x1 image)',
+    },
+    // curl/wget/fetch sending data to external URLs
+    {
+        pattern: /(?:curl|wget)\s+.*(?:-d\s|--data\s|--post-data\s|--upload-file\s|-F\s).*https?:\/\//g,
+        description: 'Sending data to external URL via curl/wget',
+    },
+    // DNS exfiltration pattern
+    {
+        pattern: /(?:dig|nslookup|host)\s+[^\s]*\$[{(]|\$\([^)]*\)\.[\w.-]+\.\w{2,}/g,
+        description: 'Potential DNS exfiltration (dynamic subdomain query)',
+    },
+    // Webhook URLs (common exfil destinations)
+    {
+        pattern: /https?:\/\/(?:(?:hooks\.slack\.com|discord(?:app)?\.com\/api\/webhooks|webhook\.site|requestbin\.com|pipedream\.net|hookbin\.com|burpcollaborator\.net|interact\.sh|canarytokens\.com)[^\s"')<]*)/gi,
+        description: 'Webhook or request-capture URL (common exfiltration destination)',
+    },
+    // Sending environment variables or secrets to external URLs
+    {
+        pattern: /(?:curl|wget|fetch|http\.post|requests\.post)\s*[(\s].*(?:\$\{?\w*(?:SECRET|TOKEN|KEY|PASSWORD|API_KEY|AWS_)\w*\}?|process\.env\.\w+|os\.environ)/gi,
+        description: 'Sending environment variables/secrets to external endpoint',
+    },
+];
+exports.dataExfiltrationRule = {
+    id: 'data-exfiltration',
+    category: 'data-exfiltration',
+    description: 'Detects data exfiltration patterns — image-based exfil, tracking pixels, webhook exfil',
+    defaultSeverity: 'high',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of DATA_EXFILTRATION_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'data-exfiltration', 'data-exfiltration', description, 'high'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data-exfiltration.js.map

package/dist/security-scanner/rules/data-exfiltration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-exfiltration.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/data-exfiltration.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;GAGG;AACH,MAAM,0BAA0B,GAA+C;IAC7E,uEAAuE;IACvE;QACE,OAAO,EAAE,4DAA4D;QACrE,WAAW,EAAE,yEAAyE;KACvF;IACD,oEAAoE;IACpE;QACE,OAAO,EACL,kHAAkH;QACpH,WAAW,EAAE,wDAAwD;KACtE;IACD,8CAA8C;IAC9C;QACE,OAAO,EACL,kHAAkH;QACpH,WAAW,EAAE,4BAA4B;KAC1C;IACD,gDAAgD;IAChD;QACE,OAAO,EAAE,sFAAsF;QAC/F,WAAW,EAAE,4CAA4C;KAC1D;IACD,2BAA2B;IAC3B;QACE,OAAO,EAAE,oEAAoE;QAC7E,WAAW,EAAE,sDAAsD;KACpE;IACD,2CAA2C;IAC3C;QACE,OAAO,EACL,qMAAqM;QACvM,WAAW,EAAE,kEAAkE;KAChF;IACD,4DAA4D;IAC5D;QACE,OAAO,EACL,qJAAqJ;QACvJ,WAAW,EAAE,4DAA4D;KAC1E;CACF,CAAC;AAEW,QAAA,oBAAoB,GAAiB;IAChD,EAAE,EAAE,mBAAmB;IACvB,QAAQ,EAAE,mBAAmB;IAC7B,WAAW,EACT,wFAAwF;IAC1F,eAAe,EAAE,MAAM;IACvB,MAAM,CAAC,OAAO;QACZ,MAAM,QAAQ,GAAsB,EAAE,CAAC;QACvC,MAAM,eAAe,GAAG,IAAA,yCAAoB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3D,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,0BAA0B,EAAE,CAAC;YAClE,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,MAAM,CACP,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/index.d.ts

@@ -0,0 +1,12 @@
+import type { SecurityRule } from '../types';
+import { agentHijackingRule } from './agent-hijacking';
+import { dangerousExecutionRule } from './dangerous-execution';
+import { dataExfiltrationRule } from './data-exfiltration';
+import { promptInjectionRule } from './prompt-injection';
+import { supplyChainRule } from './supply-chain';
+import { unicodeAttacksRule } from './unicode-attacks';
+import { urlThreatsRule } from './url-threats';
+import { xssHtmlInjectionRule } from './xss-html-injection';
+export { agentHijackingRule, dangerousExecutionRule, dataExfiltrationRule, promptInjectionRule, supplyChainRule, unicodeAttacksRule, urlThreatsRule, xssHtmlInjectionRule, };
+export declare const defaultSecurityRules: SecurityRule[];
+//# sourceMappingURL=index.d.ts.map

package/dist/security-scanner/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,YAAY,EAS9C,CAAC"}