@ai-dossier/core 1.2.0 → 1.3.1

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSecurityRules = exports.xssHtmlInjectionRule = exports.urlThreatsRule = exports.unicodeAttacksRule = exports.supplyChainRule = exports.promptInjectionRule = exports.dataExfiltrationRule = exports.dangerousExecutionRule = exports.agentHijackingRule = void 0;
+const agent_hijacking_1 = require("./agent-hijacking");
+Object.defineProperty(exports, "agentHijackingRule", { enumerable: true, get: function () { return agent_hijacking_1.agentHijackingRule; } });
+const dangerous_execution_1 = require("./dangerous-execution");
+Object.defineProperty(exports, "dangerousExecutionRule", { enumerable: true, get: function () { return dangerous_execution_1.dangerousExecutionRule; } });
+const data_exfiltration_1 = require("./data-exfiltration");
+Object.defineProperty(exports, "dataExfiltrationRule", { enumerable: true, get: function () { return data_exfiltration_1.dataExfiltrationRule; } });
+const prompt_injection_1 = require("./prompt-injection");
+Object.defineProperty(exports, "promptInjectionRule", { enumerable: true, get: function () { return prompt_injection_1.promptInjectionRule; } });
+const supply_chain_1 = require("./supply-chain");
+Object.defineProperty(exports, "supplyChainRule", { enumerable: true, get: function () { return supply_chain_1.supplyChainRule; } });
+const unicode_attacks_1 = require("./unicode-attacks");
+Object.defineProperty(exports, "unicodeAttacksRule", { enumerable: true, get: function () { return unicode_attacks_1.unicodeAttacksRule; } });
+const url_threats_1 = require("./url-threats");
+Object.defineProperty(exports, "urlThreatsRule", { enumerable: true, get: function () { return url_threats_1.urlThreatsRule; } });
+const xss_html_injection_1 = require("./xss-html-injection");
+Object.defineProperty(exports, "xssHtmlInjectionRule", { enumerable: true, get: function () { return xss_html_injection_1.xssHtmlInjectionRule; } });
+exports.defaultSecurityRules = [
+    prompt_injection_1.promptInjectionRule,
+    agent_hijacking_1.agentHijackingRule,
+    dangerous_execution_1.dangerousExecutionRule,
+    unicode_attacks_1.unicodeAttacksRule,
+    data_exfiltration_1.dataExfiltrationRule,
+    xss_html_injection_1.xssHtmlInjectionRule,
+    url_threats_1.urlThreatsRule,
+    supply_chain_1.supplyChainRule,
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/index.ts"],"names":[],"mappings":";;;AACA,uDAAuD;AAUrD,mGAVO,oCAAkB,OAUP;AATpB,+DAA+D;AAU7D,uGAVO,4CAAsB,OAUP;AATxB,2DAA2D;AAUzD,qGAVO,wCAAoB,OAUP;AATtB,yDAAyD;AAUvD,oGAVO,sCAAmB,OAUP;AATrB,iDAAiD;AAU/C,gGAVO,8BAAe,OAUP;AATjB,uDAAuD;AAUrD,mGAVO,oCAAkB,OAUP;AATpB,+CAA+C;AAU7C,+FAVO,4BAAc,OAUP;AAThB,6DAA4D;AAU1D,qGAVO,yCAAoB,OAUP;AAGT,QAAA,oBAAoB,GAAmB;IAClD,sCAAmB;IACnB,oCAAkB;IAClB,4CAAsB;IACtB,oCAAkB;IAClB,wCAAoB;IACpB,yCAAoB;IACpB,4BAAc;IACd,8BAAe;CAChB,CAAC"}

package/dist/security-scanner/rules/prompt-injection.d.ts

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

package/dist/security-scanner/rules/prompt-injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-injection.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/prompt-injection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AA0C9D,eAAO,MAAM,mBAAmB,EAAE,YA0BjC,CAAC"}

package/dist/security-scanner/rules/prompt-injection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptInjectionRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns that indicate prompt injection — attempts to insert hidden instructions
+ * that an LLM would interpret as system/user directives.
+ */
+const PROMPT_INJECTION_PATTERNS = [
+    // HTML comment directives
+    {
+        pattern: /<!--\s*(system|instruction|ignore|override|forget|disregard|new\s+task)[\s\S]*?-->/gi,
+        description: 'HTML comment containing directive keywords',
+    },
+    // Explicit system prompt injection markers
+    {
+        pattern: /\[SYSTEM\]|\[INST\]|\[\/INST\]|<\|im_start\|>|<\|im_end\|>/gi,
+        description: 'LLM chat template markers (system/inst delimiters)',
+    },
+    // Attempts to redefine the assistant identity
+    {
+        pattern: /you\s+are\s+(?:now|a\s+new|no\s+longer)\b|from\s+now\s+on,?\s+(?:you|ignore|forget)/gi,
+        description: 'Identity override attempt',
+    },
+    // "Ignore previous" family
+    {
+        pattern: /(?:ignore|disregard|forget|override)\s+(?:all\s+)?(?:previous|above|prior|earlier)\s+(?:instructions?|rules?|context|prompts?|constraints?)/gi,
+        description: 'Instruction override attempt ("ignore previous...")',
+    },
+    // Hidden text via HTML attributes
+    {
+        pattern: /<\w+[^>]*\bstyle\s*=\s*["'][^"']*(?:display\s*:\s*none|visibility\s*:\s*hidden|font-size\s*:\s*0|opacity\s*:\s*0|color\s*:\s*(?:white|transparent|#fff(?:fff)?))[^"']*["'][^>]*>/gi,
+        description: 'HTML element with hidden/invisible styling',
+    },
+    // Base64-encoded payloads that look like embedded instructions
+    {
+        pattern: /<!--[\s\S]*?(?:[A-Za-z0-9+/]{40,}={0,2})[\s\S]*?-->/g,
+        description: 'HTML comment containing base64-encoded payload',
+    },
+];
+exports.promptInjectionRule = {
+    id: 'prompt-injection',
+    category: 'prompt-injection',
+    description: 'Detects prompt injection patterns — hidden instructions and system prompt overrides',
+    defaultSeverity: 'critical',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of PROMPT_INJECTION_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'prompt-injection', 'prompt-injection', description, 'critical'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=prompt-injection.js.map

package/dist/security-scanner/rules/prompt-injection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-injection.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/prompt-injection.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;GAGG;AACH,MAAM,yBAAyB,GAA+C;IAC5E,0BAA0B;IAC1B;QACE,OAAO,EAAE,sFAAsF;QAC/F,WAAW,EAAE,4CAA4C;KAC1D;IACD,2CAA2C;IAC3C;QACE,OAAO,EAAE,8DAA8D;QACvE,WAAW,EAAE,oDAAoD;KAClE;IACD,8CAA8C;IAC9C;QACE,OAAO,EACL,uFAAuF;QACzF,WAAW,EAAE,2BAA2B;KACzC;IACD,2BAA2B;IAC3B;QACE,OAAO,EACL,+IAA+I;QACjJ,WAAW,EAAE,qDAAqD;KACnE;IACD,kCAAkC;IAClC;QACE,OAAO,EACL,oLAAoL;QACtL,WAAW,EAAE,4CAA4C;KAC1D;IACD,+DAA+D;IAC/D;QACE,OAAO,EAAE,sDAAsD;QAC/D,WAAW,EAAE,gDAAgD;KAC9D;CACF,CAAC;AAEW,QAAA,mBAAmB,GAAiB;IAC/C,EAAE,EAAE,kBAAkB;IACtB,QAAQ,EAAE,kBAAkB;IAC5B,WAAW,EACT,qFAAqF;IACvF,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,yBAAyB,EAAE,CAAC;YACjE,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,WAAW,EACX,UAAU,CACX,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/supply-chain.d.ts

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

package/dist/security-scanner/rules/supply-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supply-chain.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/supply-chain.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AAkD9D,eAAO,MAAM,eAAe,EAAE,YA0B7B,CAAC"}

package/dist/security-scanner/rules/supply-chain.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supplyChainRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns for supply chain attacks — fake prerequisites, hook exploitation,
+ * package confusion, and CSV injection.
+ */
+const SUPPLY_CHAIN_PATTERNS = [
+    // Installing packages from suspicious or unqualified sources
+    {
+        pattern: /(?:npm\s+install|pip\s+install|gem\s+install|go\s+get|cargo\s+install)\s+.*(?:--registry|--index-url|--extra-index-url|--trusted-host)\s+https?:\/\//g,
+        description: 'Package installation from custom/untrusted registry',
+    },
+    // Git hooks injection (pre-commit, post-checkout, etc.)
+    {
+        pattern: /\.git\/hooks\/(?:pre-commit|post-commit|pre-push|post-checkout|pre-receive|post-receive|prepare-commit-msg)/g,
+        description: 'Git hook file reference (potential hook exploitation)',
+    },
+    // npm scripts that run arbitrary commands
+    {
+        pattern: /["'](?:preinstall|postinstall|preuninstall|postuninstall|prepublish|prepare)["']\s*:\s*["'][^"']*(?:curl|wget|bash|sh|node\s+-e|python\s+-c)[^"']*["']/g,
+        description: 'npm lifecycle script with shell/network command',
+    },
+    // CSV injection patterns (formulas that execute when opened in spreadsheets)
+    {
+        pattern: /(?:^|[,|;])\s*[=+@-]\s*(?:cmd|system|exec|call)\s*\(/gm,
+        description: 'CSV injection formula (potential code execution in spreadsheets)',
+    },
+    // Typosquatting indicators — instructions to install packages with unusual names
+    {
+        pattern: /(?:npm\s+install|pip\s+install)\s+(?:[a-z]+-[a-z]+-[a-z]+-[a-z]+|[a-z]{1,3}-[a-z]+)\s/g,
+        description: 'Package installation with potentially typosquatted name (very short or heavily hyphenated)',
+    },
+    // Makefile or shell script downloading and executing
+    {
+        pattern: /(?:make|\.\/\w+\.sh)\b.*&&.*(?:curl|wget)\s+.*\|\s*(?:ba)?sh/g,
+        description: 'Build script downloading and executing remote code',
+    },
+    // npm/pip install from git URL (bypasses registry security)
+    {
+        pattern: /(?:npm\s+install|pip\s+install)\s+(?:git\+)?https?:\/\/(?!github\.com\/|gitlab\.com\/|bitbucket\.org\/)[^\s]+/g,
+        description: 'Package installation from non-standard git URL',
+    },
+];
+exports.supplyChainRule = {
+    id: 'supply-chain',
+    category: 'supply-chain',
+    description: 'Detects supply chain attack patterns — untrusted registries, hook exploitation, CSV injection',
+    defaultSeverity: 'medium',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of SUPPLY_CHAIN_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'supply-chain', 'supply-chain', description, 'medium'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=supply-chain.js.map

package/dist/security-scanner/rules/supply-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supply-chain.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/supply-chain.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;GAGG;AACH,MAAM,qBAAqB,GAA+C;IACxE,6DAA6D;IAC7D;QACE,OAAO,EACL,uJAAuJ;QACzJ,WAAW,EAAE,qDAAqD;KACnE;IACD,wDAAwD;IACxD;QACE,OAAO,EACL,8GAA8G;QAChH,WAAW,EAAE,uDAAuD;KACrE;IACD,0CAA0C;IAC1C;QACE,OAAO,EACL,yJAAyJ;QAC3J,WAAW,EAAE,iDAAiD;KAC/D;IACD,6EAA6E;IAC7E;QACE,OAAO,EAAE,wDAAwD;QACjE,WAAW,EAAE,kEAAkE;KAChF;IACD,iFAAiF;IACjF;QACE,OAAO,EACL,wFAAwF;QAC1F,WAAW,EACT,4FAA4F;KAC/F;IACD,qDAAqD;IACrD;QACE,OAAO,EAAE,+DAA+D;QACxE,WAAW,EAAE,oDAAoD;KAClE;IACD,4DAA4D;IAC5D;QACE,OAAO,EACL,gHAAgH;QAClH,WAAW,EAAE,gDAAgD;KAC9D;CACF,CAAC;AAEW,QAAA,eAAe,GAAiB;IAC3C,EAAE,EAAE,cAAc;IAClB,QAAQ,EAAE,cAAc;IACxB,WAAW,EACT,+FAA+F;IACjG,eAAe,EAAE,QAAQ;IACzB,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,qBAAqB,EAAE,CAAC;YAC7D,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,cAAc,EACd,cAAc,EACd,WAAW,EACX,QAAQ,CACT,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/unicode-attacks.d.ts

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

package/dist/security-scanner/rules/unicode-attacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicode-attacks.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/unicode-attacks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,YAAY,EAAoB,MAAM,UAAU,CAAC;AAuDhF,eAAO,MAAM,kBAAkB,EAAE,YAkChC,CAAC"}

package/dist/security-scanner/rules/unicode-attacks.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unicodeAttacksRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+/**
+ * Detects suspicious Unicode characters that can be used to hide text,
+ * create visually misleading content, or smuggle instructions.
+ *
+ * Note: We use individual character alternation instead of character classes
+ * for zero-width characters because some (like ZWJ U+200D) are joiners that
+ * compose emoji sequences, and biome's `noMisleadingCharacterClass` rule
+ * flags them inside character classes.
+ */
+const UNICODE_ATTACK_PATTERNS = [
+    // Zero-width characters (ZWSP, ZWNJ, ZWJ, zero-width no-break space)
+    // Using alternation instead of character class to avoid noMisleadingCharacterClass
+    {
+        pattern: /\u200B|\u200C|\u200D|\uFEFF/g,
+        description: 'Zero-width character detected (potential hidden text)',
+        severity: 'high',
+    },
+    // Unicode Tags Block (U+E0001-U+E007F) — used for invisible text smuggling
+    {
+        pattern: /[\u{E0001}-\u{E007F}]/gu,
+        description: 'Unicode Tags Block character (invisible text smuggling)',
+        severity: 'critical',
+    },
+    // Right-to-left override/embedding (text direction attacks)
+    {
+        pattern: /[\u202A-\u202E\u2066-\u2069]/g,
+        description: 'Bidirectional text override character (visual spoofing)',
+        severity: 'high',
+    },
+    // Interlinear annotation markers
+    {
+        pattern: /[\uFFF9-\uFFFB]/g,
+        description: 'Interlinear annotation character',
+        severity: 'medium',
+    },
+    // Homoglyph-heavy sequences — Cyrillic/Greek characters in otherwise Latin text
+    {
+        pattern: /[a-zA-Z]+[\u0400-\u04FF]+|[\u0400-\u04FF]+[a-zA-Z]+/g,
+        description: 'Mixed Latin/Cyrillic script (potential homoglyph attack)',
+        severity: 'medium',
+    },
+    // Object replacement character that can hide content
+    {
+        pattern: /\uFFFC/g,
+        description: 'Object replacement character',
+        severity: 'low',
+    },
+];
+exports.unicodeAttacksRule = {
+    id: 'unicode-attacks',
+    category: 'unicode-attacks',
+    description: 'Detects suspicious Unicode characters — zero-width chars, bidi overrides, Tags Block, homoglyphs',
+    defaultSeverity: 'high',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description, severity } of UNICODE_ATTACK_PATTERNS) {
+            // matchAll requires a fresh regex or one with global flag
+            const globalPattern = pattern.global
+                ? new RegExp(pattern.source, pattern.flags)
+                : new RegExp(pattern.source, `${pattern.flags}g`);
+            for (const match of context.body.matchAll(globalPattern)) {
+                const line = (0, code_block_context_1.getLineNumber)(context.body, match.index ?? 0);
+                const inCodeBlock = (0, code_block_context_1.isLineInCodeBlock)(line, codeBlockRanges);
+                findings.push({
+                    ruleId: 'unicode-attacks',
+                    category: 'unicode-attacks',
+                    severity: inCodeBlock ? 'info' : severity,
+                    message: `Unicode attack: ${description}`,
+                    evidence: `U+${match[0].codePointAt(0)?.toString(16).toUpperCase().padStart(4, '0')}`,
+                    line,
+                    inCodeBlock,
+                });
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=unicode-attacks.js.map

package/dist/security-scanner/rules/unicode-attacks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicode-attacks.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/unicode-attacks.ts"],"names":[],"mappings":";;;AAAA,8DAA+F;AAG/F;;;;;;;;GAQG;AACH,MAAM,uBAAuB,GAIvB;IACJ,qEAAqE;IACrE,mFAAmF;IACnF;QACE,OAAO,EAAE,8BAA8B;QACvC,WAAW,EAAE,uDAAuD;QACpE,QAAQ,EAAE,MAAM;KACjB;IACD,2EAA2E;IAC3E;QACE,OAAO,EAAE,yBAAyB;QAClC,WAAW,EAAE,yDAAyD;QACtE,QAAQ,EAAE,UAAU;KACrB;IACD,4DAA4D;IAC5D;QACE,OAAO,EAAE,+BAA+B;QACxC,WAAW,EAAE,yDAAyD;QACtE,QAAQ,EAAE,MAAM;KACjB;IACD,iCAAiC;IACjC;QACE,OAAO,EAAE,kBAAkB;QAC3B,WAAW,EAAE,kCAAkC;QAC/C,QAAQ,EAAE,QAAQ;KACnB;IACD,gFAAgF;IAChF;QACE,OAAO,EAAE,sDAAsD;QAC/D,WAAW,EAAE,0DAA0D;QACvE,QAAQ,EAAE,QAAQ;KACnB;IACD,qDAAqD;IACrD;QACE,OAAO,EAAE,SAAS;QAClB,WAAW,EAAE,8BAA8B;QAC3C,QAAQ,EAAE,KAAK;KAChB;CACF,CAAC;AAEW,QAAA,kBAAkB,GAAiB;IAC9C,EAAE,EAAE,iBAAiB;IACrB,QAAQ,EAAE,iBAAiB;IAC3B,WAAW,EACT,kGAAkG;IACpG,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,QAAQ,EAAE,IAAI,uBAAuB,EAAE,CAAC;YACzE,0DAA0D;YAC1D,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM;gBAClC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC;gBAC3C,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;YAEpD,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;gBACzD,MAAM,IAAI,GAAG,IAAA,kCAAa,EAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;gBAC3D,MAAM,WAAW,GAAG,IAAA,sCAAiB,EAAC,IAAI,EAAE,eAAe,CAAC,CAAC;gBAE7D,QAAQ,CAAC,IAAI,CAAC;oBACZ,MAAM,EAAE,iBAAiB;oBACzB,QAAQ,EAAE,iBAAiB;oBAC3B,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ;oBACzC,OAAO,EAAE,mBAAmB,WAAW,EAAE;oBACzC,QAAQ,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;oBACrF,IAAI;oBACJ,WAAW;iBACZ,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/url-threats.d.ts

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

package/dist/security-scanner/rules/url-threats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-threats.d.ts","sourceRoot":"","sources":["../../../src/security-scanner/rules/url-threats.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,UAAU,CAAC;AA+D9D,eAAO,MAAM,cAAc,EAAE,YA6C5B,CAAC"}

package/dist/security-scanner/rules/url-threats.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlThreatsRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * URL shortener and redirect service domains that can disguise malicious destinations.
+ */
+const URL_SHORTENER_DOMAINS = [
+    'bit.ly',
+    'tinyurl.com',
+    't.co',
+    'goo.gl',
+    'ow.ly',
+    'is.gd',
+    'buff.ly',
+    'adf.ly',
+    'bl.ink',
+    'lnkd.in',
+    'soo.gd',
+    'rb.gy',
+    's.id',
+    'v.gd',
+    'clck.ru',
+    'shorturl.at',
+    'cutt.ly',
+];
+/**
+ * Patterns for URL-based threats — shorteners, punycode, suspicious TLDs,
+ * and IP-based URLs that may disguise malicious destinations.
+ */
+const URL_THREAT_PATTERNS = [
+    // Punycode domains (internationalized domain names that can mimic legitimate domains)
+    {
+        pattern: /https?:\/\/xn--[a-z0-9-]+\.[a-z]{2,}/gi,
+        description: 'Punycode domain (potential homograph attack)',
+    },
+    // IP address URLs (decimal)
+    {
+        pattern: /https?:\/\/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(?::\d+)?(?:\/[^\s]*)?/g,
+        description: 'IP-address URL (no domain name — potential evasion)',
+    },
+    // IP address URLs (decimal-encoded single integer, e.g., http://2130706433)
+    {
+        pattern: /https?:\/\/\d{8,10}(?:\/[^\s]*)?/g,
+        description: 'Decimal-encoded IP URL (obfuscated destination)',
+    },
+    // Hex-encoded URL
+    {
+        pattern: /https?:\/\/0x[0-9a-fA-F]+(?:\/[^\s]*)?/g,
+        description: 'Hex-encoded IP URL (obfuscated destination)',
+    },
+    // URLs with excessive redirects via query params
+    {
+        pattern: /https?:\/\/[^\s]*(?:redirect|redir|goto|next|return|url|continue|destination)\s*=\s*https?(?:%3A|:)/gi,
+        description: 'URL with redirect parameter (potential open redirect)',
+    },
+    // URLs with @ symbol (credential stuffing in URL)
+    {
+        pattern: /https?:\/\/[^@\s]+@[^@\s]+\.[a-z]{2,}/gi,
+        description: 'URL with embedded credentials (user@host format)',
+    },
+];
+exports.urlThreatsRule = {
+    id: 'url-threats',
+    category: 'url-threats',
+    description: 'Detects URL-based threats — shorteners, punycode domains, IP-based URLs, open redirects',
+    defaultSeverity: 'medium',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        // Check for URL shorteners
+        const shortenerPattern = new RegExp(`https?:\\/\\/(?:${URL_SHORTENER_DOMAINS.map((d) => d.replace(/\./g, '\\.')).join('|')})\\/[^\\s"')<]+`, 'gi');
+        findings.push(...(0, match_utils_1.matchPattern)(context.body, shortenerPattern, codeBlockRanges, 'url-threats', 'url-threats', 'Shortened URL (destination unknown — could disguise malicious target)', 'medium'));
+        // Check other URL threat patterns
+        for (const { pattern, description } of URL_THREAT_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'url-threats', 'url-threats', description, 'medium'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=url-threats.js.map

package/dist/security-scanner/rules/url-threats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-threats.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/url-threats.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;GAEG;AACH,MAAM,qBAAqB,GAAG;IAC5B,QAAQ;IACR,aAAa;IACb,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,OAAO;IACP,MAAM;IACN,MAAM;IACN,SAAS;IACT,aAAa;IACb,SAAS;CACV,CAAC;AAEF;;;GAGG;AACH,MAAM,mBAAmB,GAA+C;IACtE,sFAAsF;IACtF;QACE,OAAO,EAAE,wCAAwC;QACjD,WAAW,EAAE,8CAA8C;KAC5D;IACD,4BAA4B;IAC5B;QACE,OAAO,EAAE,sEAAsE;QAC/E,WAAW,EAAE,qDAAqD;KACnE;IACD,4EAA4E;IAC5E;QACE,OAAO,EAAE,mCAAmC;QAC5C,WAAW,EAAE,iDAAiD;KAC/D;IACD,kBAAkB;IAClB;QACE,OAAO,EAAE,yCAAyC;QAClD,WAAW,EAAE,6CAA6C;KAC3D;IACD,iDAAiD;IACjD;QACE,OAAO,EACL,uGAAuG;QACzG,WAAW,EAAE,uDAAuD;KACrE;IACD,kDAAkD;IAClD;QACE,OAAO,EAAE,yCAAyC;QAClD,WAAW,EAAE,kDAAkD;KAChE;CACF,CAAC;AAEW,QAAA,cAAc,GAAiB;IAC1C,EAAE,EAAE,aAAa;IACjB,QAAQ,EAAE,aAAa;IACvB,WAAW,EACT,yFAAyF;IAC3F,eAAe,EAAE,QAAQ;IACzB,MAAM,CAAC,OAAO;QACZ,MAAM,QAAQ,GAAsB,EAAE,CAAC;QACvC,MAAM,eAAe,GAAG,IAAA,yCAAoB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3D,2BAA2B;QAC3B,MAAM,gBAAgB,GAAG,IAAI,MAAM,CACjC,mBAAmB,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,iBAAiB,EACvG,IAAI,CACL,CAAC;QAEF,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,aAAa,EACb,uEAAuE,EACvE,QAAQ,CACT,CACF,CAAC;QAEF,kCAAkC;QAClC,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,mBAAmB,EAAE,CAAC;YAC3D,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,aAAa,EACb,aAAa,EACb,WAAW,EACX,QAAQ,CACT,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/security-scanner/rules/xss-html-injection.d.ts

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

package/dist/security-scanner/rules/xss-html-injection.d.ts.map

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

package/dist/security-scanner/rules/xss-html-injection.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xssHtmlInjectionRule = void 0;
+const code_block_context_1 = require("../code-block-context");
+const match_utils_1 = require("../match-utils");
+/**
+ * Patterns for XSS and HTML injection attacks in markdown.
+ * These detect script tags, event handlers, and dangerous URI schemes
+ * that could execute code when rendered.
+ */
+const XSS_HTML_PATTERNS = [
+    // Script tags (including obfuscated variants)
+    {
+        pattern: /<\/?script\b[^>]*>/gi,
+        description: 'Script tag detected',
+    },
+    // Event handler attributes (onclick, onerror, onload, etc.)
+    {
+        pattern: /<\w+[^>]*\bon\w+\s*=\s*["'][^"']*["'][^>]*>/gi,
+        description: 'HTML element with inline event handler',
+    },
+    // javascript: URI scheme
+    {
+        pattern: /(?:href|src|action|formaction|data)\s*=\s*["']?\s*javascript\s*:/gi,
+        description: 'JavaScript URI scheme in HTML attribute',
+    },
+    // data: URI with script content
+    {
+        pattern: /(?:href|src)\s*=\s*["']?\s*data\s*:\s*text\/html/gi,
+        description: 'Data URI with HTML content (potential XSS)',
+    },
+    // Markdown link with javascript: URI
+    {
+        pattern: /\[[^\]]*\]\(\s*javascript\s*:[^)]*\)/gi,
+        description: 'Markdown link with javascript: URI',
+    },
+    // iframe injection
+    {
+        pattern: /<iframe\b[^>]*>/gi,
+        description: 'Iframe injection',
+    },
+    // object/embed tags (can execute arbitrary content)
+    {
+        pattern: /<(?:object|embed|applet)\b[^>]*>/gi,
+        description: 'Object/embed/applet tag (potential code execution)',
+    },
+    // SVG with script or event handlers
+    {
+        pattern: /<svg\b[^>]*>[\s\S]*?(?:<script|on\w+=)/gi,
+        description: 'SVG element with embedded script or event handler',
+    },
+    // CSS expression/behavior (IE-specific but still relevant for detection)
+    {
+        pattern: /expression\s*\([^)]*\)|behavior\s*:\s*url\s*\(/gi,
+        description: 'CSS expression or behavior (potential code execution)',
+    },
+    // Meta refresh redirect
+    {
+        pattern: /<meta[^>]*http-equiv\s*=\s*["']?refresh["']?[^>]*>/gi,
+        description: 'Meta refresh redirect',
+    },
+    // Form tags (potential for phishing)
+    {
+        pattern: /<form\b[^>]*action\s*=\s*["']https?:\/\/[^"']*["'][^>]*>/gi,
+        description: 'HTML form with external action URL (potential phishing)',
+    },
+];
+exports.xssHtmlInjectionRule = {
+    id: 'xss-html-injection',
+    category: 'xss-html-injection',
+    description: 'Detects XSS and HTML injection — script tags, event handlers, dangerous URIs',
+    defaultSeverity: 'high',
+    detect(context) {
+        const findings = [];
+        const codeBlockRanges = (0, code_block_context_1.parseCodeBlockRanges)(context.body);
+        for (const { pattern, description } of XSS_HTML_PATTERNS) {
+            findings.push(...(0, match_utils_1.matchPattern)(context.body, pattern, codeBlockRanges, 'xss-html-injection', 'xss-html-injection', description, 'high'));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=xss-html-injection.js.map

package/dist/security-scanner/rules/xss-html-injection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xss-html-injection.js","sourceRoot":"","sources":["../../../src/security-scanner/rules/xss-html-injection.ts"],"names":[],"mappings":";;;AAAA,8DAA6D;AAC7D,gDAA8C;AAG9C;;;;GAIG;AACH,MAAM,iBAAiB,GAA+C;IACpE,8CAA8C;IAC9C;QACE,OAAO,EAAE,sBAAsB;QAC/B,WAAW,EAAE,qBAAqB;KACnC;IACD,4DAA4D;IAC5D;QACE,OAAO,EAAE,+CAA+C;QACxD,WAAW,EAAE,wCAAwC;KACtD;IACD,yBAAyB;IACzB;QACE,OAAO,EAAE,oEAAoE;QAC7E,WAAW,EAAE,yCAAyC;KACvD;IACD,gCAAgC;IAChC;QACE,OAAO,EAAE,oDAAoD;QAC7D,WAAW,EAAE,4CAA4C;KAC1D;IACD,qCAAqC;IACrC;QACE,OAAO,EAAE,wCAAwC;QACjD,WAAW,EAAE,oCAAoC;KAClD;IACD,mBAAmB;IACnB;QACE,OAAO,EAAE,mBAAmB;QAC5B,WAAW,EAAE,kBAAkB;KAChC;IACD,oDAAoD;IACpD;QACE,OAAO,EAAE,oCAAoC;QAC7C,WAAW,EAAE,oDAAoD;KAClE;IACD,oCAAoC;IACpC;QACE,OAAO,EAAE,0CAA0C;QACnD,WAAW,EAAE,mDAAmD;KACjE;IACD,yEAAyE;IACzE;QACE,OAAO,EAAE,kDAAkD;QAC3D,WAAW,EAAE,uDAAuD;KACrE;IACD,wBAAwB;IACxB;QACE,OAAO,EAAE,sDAAsD;QAC/D,WAAW,EAAE,uBAAuB;KACrC;IACD,qCAAqC;IACrC;QACE,OAAO,EAAE,4DAA4D;QACrE,WAAW,EAAE,yDAAyD;KACvE;CACF,CAAC;AAEW,QAAA,oBAAoB,GAAiB;IAChD,EAAE,EAAE,oBAAoB;IACxB,QAAQ,EAAE,oBAAoB;IAC9B,WAAW,EAAE,8EAA8E;IAC3F,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,iBAAiB,EAAE,CAAC;YACzD,QAAQ,CAAC,IAAI,CACX,GAAG,IAAA,0BAAY,EACb,OAAO,CAAC,IAAI,EACZ,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,MAAM,CACP,CACF,CAAC;QACJ,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,45 @@
+import type { DossierFrontmatter } from '../types';
+export type SecuritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+export type SecurityCategory = 'prompt-injection' | 'agent-hijacking' | 'dangerous-execution' | 'unicode-attacks' | 'data-exfiltration' | 'xss-html-injection' | 'url-threats' | 'supply-chain';
+export interface SecurityFinding {
+    ruleId: string;
+    category: SecurityCategory;
+    severity: SecuritySeverity;
+    message: string;
+    /** The matched text or pattern that triggered the finding */
+    evidence?: string;
+    /** Approximate line number in the body (1-based) */
+    line?: number;
+    /** Whether the finding is inside a fenced code block (lower confidence) */
+    inCodeBlock: boolean;
+}
+export interface SecurityRuleContext {
+    frontmatter: DossierFrontmatter;
+    body: string;
+    raw: string;
+}
+export interface SecurityRule {
+    id: string;
+    category: SecurityCategory;
+    description: string;
+    defaultSeverity: SecuritySeverity;
+    detect(context: SecurityRuleContext): SecurityFinding[];
+}
+export type SecurityRuleSeverityOverride = SecuritySeverity | 'off';
+export interface SecurityScanConfig {
+    rules: Record<string, SecurityRuleSeverityOverride>;
+    /** Minimum severity to include in results (default: 'info') */
+    minSeverity?: SecuritySeverity;
+}
+export interface SecurityReport {
+    file?: string;
+    findings: SecurityFinding[];
+    criticalCount: number;
+    highCount: number;
+    mediumCount: number;
+    lowCount: number;
+    infoCount: number;
+    /** Overall risk verdict */
+    verdict: 'PASS' | 'WARN' | 'FAIL';
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/security-scanner/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAE/E,MAAM,MAAM,gBAAgB,GACxB,kBAAkB,GAClB,iBAAiB,GACjB,qBAAqB,GACrB,iBAAiB,GACjB,mBAAmB,GACnB,oBAAoB,GACpB,aAAa,GACb,cAAc,CAAC;AAEnB,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,kBAAkB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,gBAAgB,CAAC;IAClC,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,eAAe,EAAE,CAAC;CACzD;AAED,MAAM,MAAM,4BAA4B,GAAG,gBAAgB,GAAG,KAAK,CAAC;AAEpE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC;IACpD,+DAA+D;IAC/D,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CACnC"}

package/dist/security-scanner/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/security-scanner/types.ts"],"names":[],"mappings":""}

package/dist/trace-recorder.d.ts

@@ -0,0 +1,45 @@
+export declare const VALID_TRACE_STATUSES: readonly ["running", "success", "failed", "cancelled"];
+export type TraceStatus = (typeof VALID_TRACE_STATUSES)[number];
+export interface TraceInput {
+    trace_id: string;
+    dossier: {
+        title: string;
+        version: string;
+        [key: string]: unknown;
+    };
+    agent?: {
+        name?: string;
+        version?: string;
+        [key: string]: unknown;
+    };
+    started_at: string;
+    completed_at?: string;
+    duration_ms?: number;
+    status: TraceStatus;
+    [key: string]: unknown;
+}
+export interface TraceUpdate {
+    status?: TraceStatus;
+    completed_at?: string;
+    duration_ms?: number;
+    [key: string]: unknown;
+}
+export interface StepInput {
+    step_id: string;
+    type: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+export interface TraceRecorderOptions {
+    url?: string;
+    token?: string;
+    fetch?: typeof fetch;
+}
+export interface TraceRecorder {
+    readonly enabled: boolean;
+    create(input: TraceInput): Promise<void>;
+    appendStep(traceId: string, step: StepInput): Promise<void>;
+    complete(traceId: string, update: TraceUpdate): Promise<void>;
+}
+export declare function createTraceRecorder(opts?: TraceRecorderOptions): TraceRecorder;
+//# sourceMappingURL=trace-recorder.d.ts.map

package/dist/trace-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-recorder.d.ts","sourceRoot":"","sources":["../src/trace-recorder.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,wDAAyD,CAAC;AAC3F,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IACpE,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,WAAW,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,oBAAyB,GAAG,aAAa,CAwClF"}

package/dist/trace-recorder.js

@@ -0,0 +1,43 @@
+"use strict";
+// Trace recorder for dossier execution. Opt-in: returns a no-op recorder
+// unless both DOSSIER_TRACE_URL and DOSSIER_TRACE_TOKEN (or the equivalent
+// opts) are provided. Fire-and-forget: network failures are swallowed so
+// tracing never breaks the agent run.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_TRACE_STATUSES = void 0;
+exports.createTraceRecorder = createTraceRecorder;
+exports.VALID_TRACE_STATUSES = ['running', 'success', 'failed', 'cancelled'];
+function createTraceRecorder(opts = {}) {
+    const url = opts.url ?? process.env.DOSSIER_TRACE_URL ?? '';
+    const token = opts.token ?? process.env.DOSSIER_TRACE_TOKEN ?? '';
+    const fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (!url || !token || !fetchImpl) {
+        return {
+            enabled: false,
+            create: noop,
+            appendStep: noop,
+            complete: noop,
+        };
+    }
+    const base = url.replace(/\/+$/, '');
+    const headers = {
+        'content-type': 'application/json',
+        authorization: `Bearer ${token}`,
+    };
+    const send = (method, path, body) => Promise.resolve()
+        .then(() => fetchImpl(`${base}${path}`, {
+        method,
+        headers,
+        body: JSON.stringify(body),
+    }))
+        .then(() => undefined)
+        .catch(() => undefined);
+    return {
+        enabled: true,
+        create: (input) => send('POST', '/api/v1/traces', input),
+        appendStep: (traceId, step) => send('POST', `/api/v1/traces/${encodeURIComponent(traceId)}/steps`, step),
+        complete: (traceId, update) => send('PATCH', `/api/v1/traces/${encodeURIComponent(traceId)}`, update),
+    };
+}
+async function noop() { }
+//# sourceMappingURL=trace-recorder.js.map

package/dist/trace-recorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-recorder.js","sourceRoot":"","sources":["../src/trace-recorder.ts"],"names":[],"mappings":";AAAA,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,sCAAsC;;;AA2CtC,kDAwCC;AAjFY,QAAA,oBAAoB,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAU,CAAC;AAyC3F,SAAgB,mBAAmB,CAAC,OAA6B,EAAE;IACjE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,EAAE,CAAC;IAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,EAAE,CAAC;IAClE,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC;IAEjD,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;QACjC,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,IAAI;YACZ,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG;QACd,cAAc,EAAE,kBAAkB;QAClC,aAAa,EAAE,UAAU,KAAK,EAAE;KACjC,CAAC;IAEF,MAAM,IAAI,GAAG,CAAC,MAAc,EAAE,IAAY,EAAE,IAAa,EAAiB,EAAE,CAC1E,OAAO,CAAC,OAAO,EAAE;SACd,IAAI,CAAC,GAAG,EAAE,CACT,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,EAAE;QAC1B,MAAM;QACN,OAAO;QACP,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;KAC3B,CAAC,CACH;SACA,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;SACrB,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAE5B,OAAO;QACL,OAAO,EAAE,IAAI;QACb,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,CAAC;QACxD,UAAU,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAC5B,IAAI,CAAC,MAAM,EAAE,kBAAkB,kBAAkB,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC;QAC3E,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAC5B,IAAI,CAAC,OAAO,EAAE,kBAAkB,kBAAkB,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC;KACzE,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,IAAI,KAAmB,CAAC"}