@skillsmith/core 0.11.7 → 0.12.0

package/dist/src/security/scanner/SecurityScanner.paste-host.js

@@ -0,0 +1,342 @@
+/**
+ * Security Scanner — paste/snippet-host reputation + fetch-context escalation
+ * @module @skillsmith/core/security/scanner/SecurityScanner.paste-host
+ *
+ * SMI-6033 Wave 3 (Gap 4 fix): the originally-shipped version of this
+ * detector (commit b74c18436) implemented a SIMPLER, and in one specific way
+ * INCORRECT, design relative to the approved plan
+ * (docs/internal/implementation/smi-6033-clawhavoc-scanner-gaps.md, Gap 4):
+ * it used a single flat PASTE_HOST_DOMAINS list (incorrectly including
+ * transfer.sh/file.io alongside glot.io/pastebin.com) and treated ANY
+ * same-line fetch of a paste-host URL as standalone-critical, with no
+ * requirement that the fetched content actually be EXECUTED. This file fixes
+ * both:
+ *
+ *   1. Two separate reputation tiers (patterns.ts): `ANON_PASTE_HOSTS` (+
+ *      `URL_SHORTENER_DOMAINS`, execution-gated the same way) vs.
+ *      `TRANSIENT_TRANSFER_HOSTS` (never standalone-critical — a deliberate,
+ *      documented exception for legitimate debugging/incident-response
+ *      fetches of ephemeral reproducers).
+ *   2. Execution evidence is now REQUIRED for `ANON_PASTE_HOSTS`/shorteners
+ *      to reach critical — either (a) the URL is piped directly to an
+ *      interpreter on the same line (`curl <url> | bash`, no intermediate
+ *      file), (b) `npx <url>` directly executes the fetched content (no
+ *      pipe, no intermediate file either), or (c) the fetch destination is
+ *      subsequently executed/chmod'd/sourced ELSEWHERE in the content,
+ *      correlated via the shared `isCorrelatedWithFetchDestination` utility
+ *      (SecurityScanner.fetch-correlation.ts). Fetched-but-not-executed, or
+ *      merely linked, now correctly stays at the existing scanUrls()
+ *      `url`:medium finding — no new finding here.
+ *
+ * (a)/(b) are a NEW, local execution-detection shape distinct from (c):
+ * `isCorrelatedWithFetchDestination` only detects "was this basename later
+ * written as a fetch command's DOWNLOAD DESTINATION, then referenced
+ * elsewhere" — it has no notion of a same-line direct pipe/direct-exec (no
+ * intermediate file at all). The direct-pipe/npx-direct-exec patterns below
+ * are local to this file (not promoted to the shared fetch-correlation
+ * module, which Gap 5's concurrent xattr fix does not touch) and are
+ * deliberately scoped to "the URL being piped/executed is specifically a
+ * paste-host or shortener domain" — `CODE_EXECUTION_PATTERNS`' own curl|bash
+ * pattern (patterns.ts) already fires independently for ANY curl|bash
+ * regardless of domain reputation; this file adds the DOMAIN-REPUTATION-aware
+ * escalation on top.
+ *
+ * `TRANSIENT_TRANSFER_HOSTS` never reaches critical: it emits
+ * `paste_host_fetch` at medium whenever it is an actual fetch target (the URL
+ * is the ARGUMENT of a same-line fetch verb — see `isActualFetchTarget`
+ * below), regardless of execution evidence — `curl file.io/x | bash` alone
+ * staying sub-threshold is intentional, not a gap (see patterns.ts's
+ * `TRANSIENT_TRANSFER_HOSTS` comment for the rationale).
+ *
+ * SMI-6033 Wave 3 (adversarial-review fix): the "is this URL fetched?" gate
+ * used to be a bare `FETCH_COMMAND_PATTERN` test against the whole LINE, so a
+ * fetch verb ANYWHERE on the line counted — `curl --version; see mirror docs
+ * at https://pastebin.com/abc` wrongly registered the pastebin URL as
+ * fetched. Replaced with `isActualFetchTarget`, which binds the URL to the
+ * verb by tokenizing the prefix that precedes it. Same bug class as Wave 4's
+ * `decoy_misdirection` fix; see `isActualFetchTarget`'s own doc comment for
+ * the two deliberate adaptations to this detector's inputs. This affects ONLY
+ * the same-line fetch-target gate — the direct-pipe and npx-direct-exec
+ * execution-evidence paths below are a different code path and are unchanged.
+ *
+ * Known, documented residual (static scanner, no network I/O): redirect-
+ * chain/final-host resolution is out of scope by design — custom domains,
+ * redirects, and compromised allowlisted hosts are a known residual.
+ */
+import { analyzeMarkdownContext, isDocumentationContext } from './SecurityScanner.helpers.js';
+import { extractUrls } from './SecurityScanner.urls.js';
+import { ANON_PASTE_HOSTS, TRANSIENT_TRANSFER_HOSTS, URL_SHORTENER_DOMAINS } from './patterns.js';
+import { safeRegexCheck, safeRegexTest } from './regex-utils.js';
+import { correlationTargetBasename, isCorrelatedWithFetchDestination, } from './SecurityScanner.fetch-correlation.js';
+// URL_SHORTENER_DOMAINS folds into the SAME critical-eligibility set as
+// ANON_PASTE_HOSTS (both require execution evidence to reach critical) —
+// they are exported separately from patterns.ts purely for documentation
+// clarity (a shortener is not a "content host" the way pastebin is).
+const ANON_PASTE_HOST_SET = new Set([...ANON_PASTE_HOSTS, ...URL_SHORTENER_DOMAINS].map((d) => d.toLowerCase()));
+const TRANSIENT_TRANSFER_HOST_SET = new Set(TRANSIENT_TRANSFER_HOSTS.map((d) => d.toLowerCase()));
+/** Which reputation tier (if any) does `url`'s hostname belong to? */
+function classifyPasteHostTier(url) {
+    let hostname;
+    try {
+        hostname = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+    const matchesSet = (set) => {
+        for (const domain of set) {
+            if (hostname === domain || hostname.endsWith('.' + domain))
+                return true;
+        }
+        return false;
+    };
+    if (matchesSet(ANON_PASTE_HOST_SET))
+        return 'anon';
+    if (matchesSet(TRANSIENT_TRANSFER_HOST_SET))
+        return 'transient';
+    return null;
+}
+// Direct pipe to an interpreter, no intermediate file: `curl <url> | bash`.
+// Anchored at the FIRST pipe (mirrors CODE_EXECUTION_PATTERNS' own curl|bash
+// shape in patterns.ts) and scoped to "the piped URL is specifically the
+// paste-host/shortener URL under test" by requiring the URL text to appear
+// BEFORE that pipe, alongside a fetch verb (curl/wget).
+const FETCH_VERB_PATTERN = /\b(?:curl|wget)\b/i;
+const PIPE_TO_INTERPRETER_TAIL = /^\|\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i;
+function isDirectPipeToInterpreter(url, lineContent) {
+    const pipeIndex = lineContent.indexOf('|');
+    if (pipeIndex < 0)
+        return false;
+    const beforePipe = lineContent.slice(0, pipeIndex);
+    if (!beforePipe.includes(url))
+        return false;
+    if (!safeRegexCheck(FETCH_VERB_PATTERN, beforePipe))
+        return false;
+    return safeRegexCheck(PIPE_TO_INTERPRETER_TAIL, lineContent.slice(pipeIndex));
+}
+// npx directly executes whatever it fetches from a URL — no pipe, no
+// intermediate file — so this is its own direct-execution shape (npx never
+// just downloads, so a line that fetches a URL through npx has, by that
+// fact alone, executed it).
+const NPX_DIRECT_EXEC_PATTERN = /\bnpx\b[^\n]{0,80}https?:\/\//i;
+// ============================================================================
+// Same-line fetch-TARGET binding (SMI-6033 Wave 3 adversarial-review fix)
+// ============================================================================
+/**
+ * This detector used to decide "is this paste-host URL fetched?" with a bare
+ * `FETCH_COMMAND_PATTERN` test against the whole LINE — i.e. "does a fetch
+ * verb appear anywhere on this line", not "is THIS URL the argument to that
+ * verb". `curl --version; see mirror docs at https://pastebin.com/abc`
+ * therefore registered the pastebin URL as fetched purely because the token
+ * `curl` appeared earlier in an unrelated command.
+ *
+ * Same bug class as the one already fixed in Wave 4's `decoy_misdirection`
+ * detector (`SecurityScanner.decoy.ts`'s `isActualFetchTarget`), and the fix
+ * is the same idea — tokenize the line prefix that precedes the URL and
+ * require the URL to actually be a fetch verb's argument — with two
+ * deliberate adaptations for this detector's inputs:
+ *
+ *   1. A command separator (`;`, `|`, `&`) does not disqualify the whole
+ *      line, it just bounds the search: only the segment the URL itself sits
+ *      in can bind it. `cd /tmp && curl <url> | bash` is a real attack shape
+ *      that decoy.ts's stricter "reject on any separator" rule would drop,
+ *      and this detector's whole point is catching piped/chained execution.
+ *   2. The verb need not be the FIRST token of that segment. Paste-host
+ *      fetches routinely arrive wrapped in markdown/shell decoration
+ *      (`- Run \`curl <url> | bash\``, `$ curl <url>`, `bash <(curl <url>)`),
+ *      so the check anchors on the LAST fetch verb in the segment and then
+ *      requires every token between that verb and the URL to be a flag (or
+ *      the value argument of a value-taking flag). Prose between the verb
+ *      and the URL — "see mirror docs at" — still fails, which is exactly
+ *      the FP being closed.
+ */
+const FETCH_VERB_TOKENS = new Set(['curl', 'wget', 'npx']);
+/** A bare flag token, e.g. `-o`, `-fsSL`, `--output`, `--data=x`. */
+const FLAG_TOKEN = /^-{1,2}[A-Za-z][\w-]*$/;
+/**
+ * Common curl/wget/npx flags that take a SEPARATE value token (e.g.
+ * `-o setup.sh`, `-X POST`) — that value token must be consumed as part of
+ * the flag, not mistaken for prose.
+ */
+const VALUE_TAKING_FLAGS = new Set([
+    '-o',
+    '-x',
+    '-h',
+    '-d',
+    '-a',
+    '-e',
+    '-u',
+    '-b',
+    '--output',
+    '--request',
+    '--header',
+    '--data',
+    '--data-raw',
+    '--data-binary',
+    '--data-urlencode',
+    '--user-agent',
+    '--referer',
+    '--proxy',
+    '--cookie',
+]);
+/**
+ * Strip markdown/shell decoration off a token (leading backticks, quotes,
+ * `$`/`>` prompt markers, `<(`; trailing quotes, backticks, brackets) while
+ * preserving the leading `-`/`--` that makes a flag a flag. Lowercased, so
+ * the verb and flag lookups above stay case-insensitive.
+ */
+function bareToken(token) {
+    return token
+        .replace(/^[^A-Za-z0-9/.-]+/, '')
+        .replace(/[^A-Za-z0-9/._-]+$/, '')
+        .toLowerCase();
+}
+/** Is the URL that follows `prefix` on this line the argument of a fetch verb? */
+function isFetchVerbArgument(prefix) {
+    // Only the segment after the LAST command separator can bind the URL —
+    // anything before it belongs to a different command.
+    const segment = prefix.split(/[;|&]/).pop() ?? '';
+    const tokens = segment
+        .trim()
+        .split(/\s+/)
+        .map(bareToken)
+        .filter((t) => t.length > 0);
+    let afterVerb = -1;
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i] === 'git' && tokens[i + 1] === 'clone')
+            afterVerb = i + 2;
+        else if (FETCH_VERB_TOKENS.has(tokens[i]))
+            afterVerb = i + 1;
+    }
+    if (afterVerb < 0)
+        return false;
+    for (let i = afterVerb; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!safeRegexCheck(FLAG_TOKEN, token))
+            return false;
+        if (VALUE_TAKING_FLAGS.has(token) && i + 1 < tokens.length)
+            i++; // consume the flag's value
+    }
+    return true;
+}
+/**
+ * True when `url` is actually the argument to a fetch verb somewhere on
+ * `lineContent` — checked at EVERY occurrence of the URL on the line, so a
+ * prose mention followed by a real fetch of the same URL still binds.
+ */
+function isActualFetchTarget(lineContent, url) {
+    for (let from = 0;;) {
+        const urlIndex = lineContent.indexOf(url, from);
+        if (urlIndex < 0)
+            return false;
+        if (isFetchVerbArgument(lineContent.slice(0, urlIndex)))
+            return true;
+        from = urlIndex + 1;
+    }
+}
+// Execution/chmod/source instructions whose target path is correlated
+// against a paste-host/shortener fetch's download destination via the
+// shared `isCorrelatedWithFetchDestination`. Deliberately local to this file
+// (not imported from SecurityScanner.compound.ts, which Gap 5's concurrent
+// xattr fix is editing) — same normalization (strip quotes, ≥3-char gate on
+// the final path segment) as compound.ts's own chmod correlation.
+const CHMOD_TARGET = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)\s+(\S+)/i;
+const DIRECT_EXEC_TARGET = /\b(?:sudo\s+)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\s+(\.{0,2}\/?[\w-]+(?:[./][\w-]+)*)/i;
+const DOT_SLASH_EXEC_TARGET = /(?:^|[\s;&|])\.\/([\w-]+(?:[./][\w-]+)*)/;
+// "sourced" is deliberately scoped to the portable `source X` keyword, not
+// the bare POSIX `. X` alias — the latter is too easily confused with prose
+// ("... . More info at ...") to be worth the extra correlation-signal noise.
+const SOURCE_TARGET = /(?:^|[;&|]\s*)source\s+(\.{0,2}\/?[\w-]+(?:[./][\w-]+)+)/i;
+const EXEC_TARGET_PATTERNS = [
+    CHMOD_TARGET,
+    DIRECT_EXEC_TARGET,
+    DOT_SLASH_EXEC_TARGET,
+    SOURCE_TARGET,
+];
+/**
+ * Every exec/chmod/source target PATH (final segment ≥3 chars, quotes
+ * stripped) across the document. SMI-6033 Wave 3: full paths, not basenames —
+ * the shared correlation utility is directory-aware and must not be handed a
+ * path-stripped target.
+ */
+function collectExecTargetPaths(lines) {
+    const paths = [];
+    for (const line of lines) {
+        for (const pattern of EXEC_TARGET_PATTERNS) {
+            const m = safeRegexTest(pattern, line);
+            if (!m?.[1])
+                continue;
+            const targetPath = m[1].replace(/['"]/g, '');
+            if (correlationTargetBasename(targetPath).length >= 3)
+                paths.push(targetPath);
+        }
+    }
+    return paths;
+}
+/** Was `fetchLine`'s download destination later executed/chmod'd/sourced elsewhere? */
+function isExecutedElsewhereCorrelated(fetchLine, execTargetPaths) {
+    return execTargetPaths.some((path) => isCorrelatedWithFetchDestination(path, [fetchLine]));
+}
+export function scanPasteHostFetch(content, lineContexts) {
+    const findings = [];
+    const lines = content.split('\n');
+    const contexts = lineContexts ?? analyzeMarkdownContext(content);
+    const urls = extractUrls(content);
+    const execTargetPaths = collectExecTargetPaths(lines);
+    for (const { url, line } of urls) {
+        const tier = classifyPasteHostTier(url);
+        if (!tier)
+            continue;
+        const lineIndex = line - 1;
+        const lineContent = lines[lineIndex] ?? '';
+        // The URL is a fetch TARGET only when it is ACTUALLY the argument of a
+        // fetch verb on the SAME line (SMI-6033 Wave 3 — see isActualFetchTarget
+        // above for the FP this replaced). Deliberately not widened to a bounded
+        // window (unlike the chmod/archive compound signals) since a URL
+        // literally is the thing being fetched when it is that verb's argument;
+        // widening would risk correlating an unrelated fetch command to an
+        // unrelated nearby paste-host mention.
+        if (!isActualFetchTarget(lineContent, url))
+            continue; // merely linked -> scanUrls()'s url:medium finding already covers this
+        const ctx = contexts[lineIndex];
+        const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+        if (tier === 'transient') {
+            // Always medium/co-signal-eligible, NEVER standalone-critical —
+            // regardless of execution evidence. See patterns.ts's
+            // TRANSIENT_TRANSFER_HOSTS comment for the rationale.
+            findings.push({
+                type: 'paste_host_fetch',
+                severity: inDocContext ? 'low' : 'medium',
+                message: `Ephemeral file-transfer host URL fetched (never standalone-critical by design): ${url}`,
+                location: lineContent.trim().slice(0, 100),
+                lineNumber: line,
+                category: 'paste_host_fetch',
+                inDocumentationContext: inDocContext,
+                confidence: inDocContext ? 'low' : 'medium',
+            });
+            continue;
+        }
+        // tier === 'anon' (ANON_PASTE_HOSTS or a URL shortener): critical
+        // requires actual EXECUTION evidence, not just a fetch.
+        const executed = isDirectPipeToInterpreter(url, lineContent) ||
+            safeRegexCheck(NPX_DIRECT_EXEC_PATTERN, lineContent) ||
+            isExecutedElsewhereCorrelated(lineContent, execTargetPaths);
+        if (!executed)
+            continue; // fetched but not executed -> scanUrls()'s url:medium finding already covers this
+        findings.push({
+            type: 'paste_host_fetch',
+            // Standalone-critical (execution evidence required, see above) — doc
+            // context is the only downgrade, matching every other detector's
+            // noise-reduction convention in this Wave.
+            severity: inDocContext ? 'low' : 'critical',
+            message: `Paste/snippet-host URL is the target of an execution instruction: ${url}`,
+            location: lineContent.trim().slice(0, 100),
+            lineNumber: line,
+            category: 'paste_host_fetch',
+            inDocumentationContext: inDocContext,
+            confidence: inDocContext ? 'low' : 'high',
+        });
+    }
+    return findings;
+}
+//# sourceMappingURL=SecurityScanner.paste-host.js.map

package/dist/src/security/scanner/SecurityScanner.paste-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityScanner.paste-host.js","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.paste-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAIH,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAC7F,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACjG,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EACL,yBAAyB,EACzB,gCAAgC,GACjC,MAAM,wCAAwC,CAAA;AAE/C,wEAAwE;AACxE,yEAAyE;AACzE,yEAAyE;AACzE,qEAAqE;AACrE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CACjC,CAAC,GAAG,gBAAgB,EAAE,GAAG,qBAAqB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAC5E,CAAA;AACD,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAA;AAIjG,sEAAsE;AACtE,SAAS,qBAAqB,CAAC,GAAW;IACxC,IAAI,QAAgB,CAAA;IACpB,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAA;IAChD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAA;IACb,CAAC;IACD,MAAM,UAAU,GAAG,CAAC,GAAgB,EAAW,EAAE;QAC/C,KAAK,MAAM,MAAM,IAAI,GAAG,EAAE,CAAC;YACzB,IAAI,QAAQ,KAAK,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,GAAG,MAAM,CAAC;gBAAE,OAAO,IAAI,CAAA;QACzE,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;IACD,IAAI,UAAU,CAAC,mBAAmB,CAAC;QAAE,OAAO,MAAM,CAAA;IAClD,IAAI,UAAU,CAAC,2BAA2B,CAAC;QAAE,OAAO,WAAW,CAAA;IAC/D,OAAO,IAAI,CAAA;AACb,CAAC;AAED,4EAA4E;AAC5E,6EAA6E;AAC7E,yEAAyE;AACzE,2EAA2E;AAC3E,wDAAwD;AACxD,MAAM,kBAAkB,GAAG,oBAAoB,CAAA;AAC/C,MAAM,wBAAwB,GAC5B,wGAAwG,CAAA;AAE1G,SAAS,yBAAyB,CAAC,GAAW,EAAE,WAAmB;IACjE,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IAC1C,IAAI,SAAS,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IAC/B,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;IAClD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IAC3C,IAAI,CAAC,cAAc,CAAC,kBAAkB,EAAE,UAAU,CAAC;QAAE,OAAO,KAAK,CAAA;IACjE,OAAO,cAAc,CAAC,wBAAwB,EAAE,WAAW,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAA;AAC/E,CAAC;AAED,qEAAqE;AACrE,2EAA2E;AAC3E,wEAAwE;AACxE,4BAA4B;AAC5B,MAAM,uBAAuB,GAAG,gCAAgC,CAAA;AAEhE,+EAA+E;AAC/E,0EAA0E;AAC1E,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAC1D,qEAAqE;AACrE,MAAM,UAAU,GAAG,wBAAwB,CAAA;AAC3C;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,UAAU;IACV,WAAW;IACX,UAAU;IACV,QAAQ;IACR,YAAY;IACZ,eAAe;IACf,kBAAkB;IAClB,cAAc;IACd,WAAW;IACX,SAAS;IACT,UAAU;CACX,CAAC,CAAA;AAEF;;;;;GAKG;AACH,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,KAAK;SACT,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC;SAChC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC;SACjC,WAAW,EAAE,CAAA;AAClB,CAAC;AAED,kFAAkF;AAClF,SAAS,mBAAmB,CAAC,MAAc;IACzC,uEAAuE;IACvE,qDAAqD;IACrD,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAA;IACjD,MAAM,MAAM,GAAG,OAAO;SACnB,IAAI,EAAE;SACN,KAAK,CAAC,KAAK,CAAC;SACZ,GAAG,CAAC,SAAS,CAAC;SACd,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAC9B,IAAI,SAAS,GAAG,CAAC,CAAC,CAAA;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,OAAO;YAAE,SAAS,GAAG,CAAC,GAAG,CAAC,CAAA;aAClE,IAAI,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAAE,SAAS,GAAG,CAAC,GAAG,CAAC,CAAA;IAC9D,CAAC;IACD,IAAI,SAAS,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IAC/B,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;QACvB,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC;YAAE,OAAO,KAAK,CAAA;QACpD,IAAI,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM;YAAE,CAAC,EAAE,CAAA,CAAC,2BAA2B;IAC7F,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,WAAmB,EAAE,GAAW;IAC3D,KAAK,IAAI,IAAI,GAAG,CAAC,IAAM,CAAC;QACtB,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QAC/C,IAAI,QAAQ,GAAG,CAAC;YAAE,OAAO,KAAK,CAAA;QAC9B,IAAI,mBAAmB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;YAAE,OAAO,IAAI,CAAA;QACpE,IAAI,GAAG,QAAQ,GAAG,CAAC,CAAA;IACrB,CAAC;AACH,CAAC;AAED,sEAAsE;AACtE,sEAAsE;AACtE,6EAA6E;AAC7E,2EAA2E;AAC3E,4EAA4E;AAC5E,kEAAkE;AAClE,MAAM,YAAY,GAChB,mHAAmH,CAAA;AACrH,MAAM,kBAAkB,GACtB,oHAAoH,CAAA;AACtH,MAAM,qBAAqB,GAAG,0CAA0C,CAAA;AACxE,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,MAAM,aAAa,GAAG,2DAA2D,CAAA;AACjF,MAAM,oBAAoB,GAAG;IAC3B,YAAY;IACZ,kBAAkB;IAClB,qBAAqB;IACrB,aAAa;CACd,CAAA;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,KAAwB;IACtD,MAAM,KAAK,GAAa,EAAE,CAAA;IAC1B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,MAAM,OAAO,IAAI,oBAAoB,EAAE,CAAC;YAC3C,MAAM,CAAC,GAAG,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;YACtC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAAE,SAAQ;YACrB,MAAM,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;YAC5C,IAAI,yBAAyB,CAAC,UAAU,CAAC,CAAC,MAAM,IAAI,CAAC;gBAAE,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAC/E,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,uFAAuF;AACvF,SAAS,6BAA6B,CACpC,SAAiB,EACjB,eAAkC;IAElC,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,gCAAgC,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;AAC5F,CAAC;AAED,MAAM,UAAU,kBAAkB,CAChC,OAAe,EACf,YAA4B;IAE5B,MAAM,QAAQ,GAAsB,EAAE,CAAA;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,QAAQ,GAAG,YAAY,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAA;IAChE,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,CAAA;IACjC,MAAM,eAAe,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAA;IAErD,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACjC,MAAM,IAAI,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAA;QACvC,IAAI,CAAC,IAAI;YAAE,SAAQ;QAEnB,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAA;QAC1B,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;QAC1C,uEAAuE;QACvE,yEAAyE;QACzE,yEAAyE;QACzE,iEAAiE;QACjE,wEAAwE;QACxE,mEAAmE;QACnE,uCAAuC;QACvC,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,GAAG,CAAC;YAAE,SAAQ,CAAC,uEAAuE;QAE5H,MAAM,GAAG,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAA;QAC/B,MAAM,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;QAE9D,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACzB,gEAAgE;YAChE,sDAAsD;YACtD,sDAAsD;YACtD,QAAQ,CAAC,IAAI,CAAC;gBACZ,IAAI,EAAE,kBAAkB;gBACxB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ;gBACzC,OAAO,EAAE,mFAAmF,GAAG,EAAE;gBACjG,QAAQ,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;gBAC1C,UAAU,EAAE,IAAI;gBAChB,QAAQ,EAAE,kBAAkB;gBAC5B,sBAAsB,EAAE,YAAY;gBACpC,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ;aAC5C,CAAC,CAAA;YACF,SAAQ;QACV,CAAC;QAED,kEAAkE;QAClE,wDAAwD;QACxD,MAAM,QAAQ,GACZ,yBAAyB,CAAC,GAAG,EAAE,WAAW,CAAC;YAC3C,cAAc,CAAC,uBAAuB,EAAE,WAAW,CAAC;YACpD,6BAA6B,CAAC,WAAW,EAAE,eAAe,CAAC,CAAA;QAC7D,IAAI,CAAC,QAAQ;YAAE,SAAQ,CAAC,kFAAkF;QAE1G,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,kBAAkB;YACxB,qEAAqE;YACrE,iEAAiE;YACjE,2CAA2C;YAC3C,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU;YAC3C,OAAO,EAAE,qEAAqE,GAAG,EAAE;YACnF,QAAQ,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;YAC1C,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,kBAAkB;YAC5B,sBAAsB,EAAE,YAAY;YACpC,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM;SAC1C,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/dist/src/security/scanner/SecurityScanner.risk-score.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Security Scanner — risk score calculation
+ * @module @skillsmith/core/security/scanner/SecurityScanner.risk-score
+ *
+ * SMI-6033 Wave 4: extracted out of `SecurityScanner.helpers.ts` (which had
+ * grown to 504/500 lines, over this repo's file-length gate, once Wave 4's
+ * `decoyMisdirection` breakdown field/switch-arm/cap/sum entries landed).
+ * This filename intentionally matches the one already referenced by the
+ * separate, still-open SMI-5879 Wave 2 PR (#2192,
+ * `feat/smi-5879-wave2-pattern-port` — see that branch's
+ * `scripts/indexer/smi5879-corroboration.types.ts`, which already names
+ * `packages/core/src/security/scanner/SecurityScanner.risk-score.ts` as its
+ * own planned extraction target for this same function): reusing the name
+ * that PR already committed to avoids a second, differently-named
+ * competing extraction landing later and forcing a rename/merge fight.
+ */
+import type { SecurityFinding, RiskScoreBreakdown } from './types.js';
+/**
+ * SMI-685: Calculate risk score from findings
+ * SMI-1513: Accounts for confidence levels (low confidence = reduced weight)
+ * Aggregates multiple findings into a risk score from 0-100
+ */
+export declare function calculateRiskScore(findings: SecurityFinding[]): {
+    total: number;
+    breakdown: RiskScoreBreakdown;
+};
+//# sourceMappingURL=SecurityScanner.risk-score.d.ts.map

package/dist/src/security/scanner/SecurityScanner.risk-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityScanner.risk-score.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.risk-score.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAqB,MAAM,YAAY,CAAA;AAGxF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG;IAC/D,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,kBAAkB,CAAA;CAC9B,CAqKA"}

package/dist/src/security/scanner/SecurityScanner.risk-score.js

@@ -0,0 +1,178 @@
+/**
+ * Security Scanner — risk score calculation
+ * @module @skillsmith/core/security/scanner/SecurityScanner.risk-score
+ *
+ * SMI-6033 Wave 4: extracted out of `SecurityScanner.helpers.ts` (which had
+ * grown to 504/500 lines, over this repo's file-length gate, once Wave 4's
+ * `decoyMisdirection` breakdown field/switch-arm/cap/sum entries landed).
+ * This filename intentionally matches the one already referenced by the
+ * separate, still-open SMI-5879 Wave 2 PR (#2192,
+ * `feat/smi-5879-wave2-pattern-port` — see that branch's
+ * `scripts/indexer/smi5879-corroboration.types.ts`, which already names
+ * `packages/core/src/security/scanner/SecurityScanner.risk-score.ts` as its
+ * own planned extraction target for this same function): reusing the name
+ * that PR already committed to avoids a second, differently-named
+ * competing extraction landing later and forcing a rename/merge fight.
+ */
+import { SEVERITY_WEIGHTS, CATEGORY_WEIGHTS } from './weights.js';
+/**
+ * SMI-685: Calculate risk score from findings
+ * SMI-1513: Accounts for confidence levels (low confidence = reduced weight)
+ * Aggregates multiple findings into a risk score from 0-100
+ */
+export function calculateRiskScore(findings) {
+    const breakdown = {
+        jailbreak: 0,
+        socialEngineering: 0,
+        promptLeaking: 0,
+        dataExfiltration: 0,
+        privilegeEscalation: 0,
+        suspiciousCode: 0,
+        sensitivePaths: 0,
+        externalUrls: 0,
+        aiDefence: 0,
+        ssrf: 0,
+        pii: 0,
+        codeExecution: 0,
+        obfuscatedDirective: 0,
+        typosquat: 0,
+        gatekeeperBypass: 0,
+        archiveEvasion: 0,
+        pasteHostFetch: 0,
+        encodedPayload: 0,
+        decoyMisdirection: 0,
+    };
+    const confidenceWeights = {
+        high: 1.0,
+        medium: 0.7,
+        low: 0.3,
+    };
+    for (const finding of findings) {
+        const severityWeight = SEVERITY_WEIGHTS[finding.severity];
+        const categoryWeight = CATEGORY_WEIGHTS[finding.type] ?? 1.0;
+        const confidenceWeight = confidenceWeights[finding.confidence ?? 'high'];
+        const score = severityWeight * categoryWeight * confidenceWeight;
+        switch (finding.type) {
+            case 'jailbreak':
+                breakdown.jailbreak += score;
+                break;
+            case 'social_engineering':
+                breakdown.socialEngineering += score;
+                break;
+            case 'prompt_leaking':
+                breakdown.promptLeaking += score;
+                break;
+            case 'data_exfiltration':
+                breakdown.dataExfiltration += score;
+                break;
+            case 'privilege_escalation':
+                breakdown.privilegeEscalation += score;
+                break;
+            case 'suspicious_pattern':
+                breakdown.suspiciousCode += score;
+                break;
+            case 'sensitive_path':
+                breakdown.sensitivePaths += score;
+                break;
+            case 'url':
+                breakdown.externalUrls += score;
+                break;
+            case 'ai_defence':
+                breakdown.aiDefence += score;
+                break;
+            case 'ssrf':
+                breakdown.ssrf += score;
+                break;
+            case 'pii':
+                breakdown.pii += score;
+                break;
+            case 'code_execution':
+                breakdown.codeExecution += score;
+                break;
+            case 'obfuscated_directive':
+                breakdown.obfuscatedDirective += score;
+                break;
+            case 'typosquat':
+                // SMI-595: this switch has NO default case — a missing arm here would
+                // silently drop every typosquat finding from the breakdown with zero
+                // compile-time or runtime error. See the switch-case coverage test in
+                // SecurityScanner.scoring.test.ts, added specifically to guard this.
+                breakdown.typosquat += score;
+                break;
+            case 'gatekeeper_bypass':
+                breakdown.gatekeeperBypass += score;
+                break;
+            case 'archive_evasion':
+                breakdown.archiveEvasion += score;
+                break;
+            case 'paste_host_fetch':
+                breakdown.pasteHostFetch += score;
+                break;
+            case 'encoded_payload':
+                breakdown.encodedPayload += score;
+                break;
+            case 'decoy_misdirection':
+                breakdown.decoyMisdirection += score;
+                break;
+        }
+    }
+    // Cap each category at 100
+    breakdown.jailbreak = Math.min(100, breakdown.jailbreak);
+    breakdown.socialEngineering = Math.min(100, breakdown.socialEngineering);
+    breakdown.promptLeaking = Math.min(100, breakdown.promptLeaking);
+    breakdown.dataExfiltration = Math.min(100, breakdown.dataExfiltration);
+    breakdown.privilegeEscalation = Math.min(100, breakdown.privilegeEscalation);
+    breakdown.suspiciousCode = Math.min(100, breakdown.suspiciousCode);
+    breakdown.sensitivePaths = Math.min(100, breakdown.sensitivePaths);
+    breakdown.externalUrls = Math.min(100, breakdown.externalUrls);
+    breakdown.aiDefence = Math.min(100, breakdown.aiDefence);
+    breakdown.ssrf = Math.min(100, breakdown.ssrf);
+    breakdown.pii = Math.min(100, breakdown.pii);
+    breakdown.codeExecution = Math.min(100, breakdown.codeExecution);
+    breakdown.obfuscatedDirective = Math.min(100, breakdown.obfuscatedDirective);
+    breakdown.typosquat = Math.min(100, breakdown.typosquat);
+    breakdown.gatekeeperBypass = Math.min(100, breakdown.gatekeeperBypass);
+    breakdown.archiveEvasion = Math.min(100, breakdown.archiveEvasion);
+    breakdown.pasteHostFetch = Math.min(100, breakdown.pasteHostFetch);
+    breakdown.encodedPayload = Math.min(100, breakdown.encodedPayload);
+    breakdown.decoyMisdirection = Math.min(100, breakdown.decoyMisdirection);
+    // SMI-5359 Wave 4.2: the two new categories use a 0.40 coefficient and are ADDITIVE
+    // (the original eleven coefficients sum to 1.0; these add on top). No code assumes the
+    // coefficients sum to 1.0, and the final Math.min(100, ...) cap is preserved — so a skill
+    // that triggers neither new category scores exactly as before (both breakdown entries 0).
+    // SMI-595: typosquat is likewise ADDITIVE, at the 0.04 coefficient already used for
+    // sensitivePaths/externalUrls/ssrf (the "advisory tier" of this second-stage formula) —
+    // NOT folded into the eleven-category budget that sums to 1.0. See weights.ts's
+    // CATEGORY_WEIGHTS.typosquat comment for the worked calculation this pairs with.
+    // SMI-6033 Wave 2: gatekeeperBypass/archiveEvasion/pasteHostFetch are
+    // ADDITIVE at the 0.40 coefficient (matching codeExecution/
+    // obfuscatedDirective's top tier) — see weights.ts's
+    // CATEGORY_WEIGHTS.gatekeeper_bypass comment for the worked calculation
+    // showing how ONE weight/coefficient pair produces both the
+    // standalone-critical and advisory-medium outcomes via severity alone.
+    // encodedPayload is likewise ADDITIVE, at the 0.04 coefficient (the same
+    // advisory tier as sensitivePaths/externalUrls/ssrf/typosquat) — see
+    // weights.ts's CATEGORY_WEIGHTS.encoded_payload comment.
+    const total = Math.min(100, Math.round(breakdown.jailbreak * 0.2 +
+        breakdown.socialEngineering * 0.11 +
+        breakdown.promptLeaking * 0.11 +
+        breakdown.dataExfiltration * 0.08 +
+        breakdown.privilegeEscalation * 0.11 +
+        breakdown.suspiciousCode * 0.07 +
+        breakdown.sensitivePaths * 0.04 +
+        breakdown.externalUrls * 0.04 +
+        breakdown.aiDefence * 0.12 +
+        breakdown.ssrf * 0.04 +
+        breakdown.pii * 0.08 +
+        breakdown.codeExecution * 0.4 +
+        breakdown.obfuscatedDirective * 0.4 +
+        breakdown.typosquat * 0.04 +
+        breakdown.gatekeeperBypass * 0.4 +
+        breakdown.archiveEvasion * 0.4 +
+        breakdown.pasteHostFetch * 0.4 +
+        breakdown.encodedPayload * 0.04 +
+        // SMI-6033 Wave 4 (Gap 6): additive 0.04, same advisory tier as encodedPayload/typosquat.
+        breakdown.decoyMisdirection * 0.04));
+    return { total, breakdown };
+}
+//# sourceMappingURL=SecurityScanner.risk-score.js.map

package/dist/src/security/scanner/SecurityScanner.risk-score.js.map

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

package/dist/src/security/scanner/SecurityScanner.urls.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Security Scanner — URL extraction
+ * @module @skillsmith/core/security/scanner/SecurityScanner.urls
+ *
+ * SMI-6033 Wave 2 (Gap 4): split out of SecurityScanner.helpers.ts, which the
+ * promotion below pushed over the 500-line audit:standards gate. Promoted
+ * out of a private SecurityScanner.ts method (`extractUrls`) so `scanUrls`
+ * and the new `scanPasteHostFetch` detector (SecurityScanner.paste-host.ts)
+ * share ONE extraction implementation instead of two
+ * independently-drifting regex sweeps over the same content. Pure
+ * extraction — behavior is unchanged from the prior private method (same
+ * regex, same per-line scan, same return shape).
+ */
+/** A URL found in scanned content, plus the (1-indexed) line it appeared on. */
+export interface ExtractedUrl {
+    url: string;
+    line: number;
+}
+export declare function extractUrls(content: string): ExtractedUrl[];
+//# sourceMappingURL=SecurityScanner.urls.d.ts.map

package/dist/src/security/scanner/SecurityScanner.urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityScanner.urls.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.urls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CAa3D"}

package/dist/src/security/scanner/SecurityScanner.urls.js

@@ -0,0 +1,26 @@
+/**
+ * Security Scanner — URL extraction
+ * @module @skillsmith/core/security/scanner/SecurityScanner.urls
+ *
+ * SMI-6033 Wave 2 (Gap 4): split out of SecurityScanner.helpers.ts, which the
+ * promotion below pushed over the 500-line audit:standards gate. Promoted
+ * out of a private SecurityScanner.ts method (`extractUrls`) so `scanUrls`
+ * and the new `scanPasteHostFetch` detector (SecurityScanner.paste-host.ts)
+ * share ONE extraction implementation instead of two
+ * independently-drifting regex sweeps over the same content. Pure
+ * extraction — behavior is unchanged from the prior private method (same
+ * regex, same per-line scan, same return shape).
+ */
+export function extractUrls(content) {
+    const urlPattern = /https?:\/\/[^\s<>"')\]]+/gi;
+    const lines = content.split('\n');
+    const results = [];
+    lines.forEach((line, index) => {
+        let match;
+        while ((match = urlPattern.exec(line)) !== null) {
+            results.push({ url: match[0], line: index + 1 });
+        }
+    });
+    return results;
+}
+//# sourceMappingURL=SecurityScanner.urls.js.map

package/dist/src/security/scanner/SecurityScanner.urls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityScanner.urls.js","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.urls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,MAAM,UAAU,GAAG,4BAA4B,CAAA;IAC/C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,OAAO,GAAmB,EAAE,CAAA;IAElC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC5B,IAAI,KAAK,CAAA;QACT,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAChD,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAA;QAClD,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,OAAO,CAAA;AAChB,CAAC"}

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

@@ -4,12 +4,12 @@
  * Re-exports for security scanning functionality.
  */
 export type { SecurityFindingType, SecuritySeverity, SecurityFinding, RiskScoreBreakdown, ScanReport, ScannerOptions, HostileUpdateVerdict, TyposquatEnforcementMode, EvidenceType, } from './types.js';
-export { DEFAULT_ALLOWED_DOMAINS, SENSITIVE_PATH_PATTERNS, JAILBREAK_PATTERNS, SUSPICIOUS_PATTERNS, SOCIAL_ENGINEERING_PATTERNS, PROMPT_LEAKING_PATTERNS, DATA_EXFILTRATION_PATTERNS, PRIVILEGE_ESCALATION_PATTERNS, AI_DEFENCE_PATTERNS, SSRF_INSTRUCTION_PATTERNS, PII_PATTERNS, CODE_EXECUTION_PATTERNS, SCANNER_RULESET_VERSION, } from './patterns.js';
+export { DEFAULT_ALLOWED_DOMAINS, SENSITIVE_PATH_PATTERNS, JAILBREAK_PATTERNS, SUSPICIOUS_PATTERNS, SOCIAL_ENGINEERING_PATTERNS, PROMPT_LEAKING_PATTERNS, DATA_EXFILTRATION_PATTERNS, PRIVILEGE_ESCALATION_PATTERNS, AI_DEFENCE_PATTERNS, SSRF_INSTRUCTION_PATTERNS, PII_PATTERNS, CODE_EXECUTION_PATTERNS, IMPERATIVE_FETCH_EXEC_PROSE, SCANNER_RULESET_VERSION, } from './patterns.js';
 export { SEVERITY_WEIGHTS, CATEGORY_WEIGHTS } from './weights.js';
 export { MAX_LINE_LENGTH_FOR_REGEX, MAX_CONTENT_LENGTH_FOR_REGEX, safeRegexTest, safeRegexCheck, } from './regex-utils.js';
 export { stripInvisible } from './SecurityScanner.exec.js';
 export { CONFUSABLES, isFullwidthLatin, isMathAlphanumeric, confusableSkeleton, } from './confusables.js';
-export { BRAND_ALIASES, levenshteinDistance, scanTyposquat, detectTyposquat, applyTyposquatEnforcementMode, resolveTyposquatEnforcementMode, DEFAULT_TYPOSQUAT_ENFORCEMENT_MODE, } from './typosquat.js';
+export { BRAND_ALIASES, AUTHORITY_CLAIMING_AFFIXES, levenshteinDistance, scanTyposquat, detectTyposquat, applyTyposquatEnforcementMode, resolveTyposquatEnforcementMode, DEFAULT_TYPOSQUAT_ENFORCEMENT_MODE, } from './typosquat.js';
 export { buildTyposquatReferenceList, DEFAULT_TOP_INSTALLED_LIMIT, } from './typosquat-reference-list.js';
 export type { ReferenceSkillEntry, InstalledSkillEntry, BuildTyposquatReferenceListOptions, } from './typosquat-reference-list.js';
 export { describeSignals } from './SecurityScanner.formatters.js';