@kaminari-ad/mcp 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.17.0] - 2026-09-03
+
+### Added
+
+- **`regexp_request_body` — rules can match what a page's sub-resources
+  contain.** The three custom-rule writers (`create_custom_rule`,
+  `update_custom_rule`, `test_custom_rule`) now accept the new rule type
+  and enforce its contract locally: the same `{pattern, flags}` config as
+  `regexp_request_url` and the same fixed `page` target, rejected before
+  the request leaves the process.
+
+  It exists because address-based matching stopped being enough. The
+  malvertising kits rotate every filename on every visit, so a
+  `regexp_request_url` pattern matches the names it was written against
+  and nothing after; the code inside those files changes far more slowly.
+
+  Two limits the tool descriptions now state, because both look like a
+  non-match when they bite: only the scripts, fetch/XHR responses and
+  iframe documents are captured (never images, video, fonts or
+  stylesheets), up to 400 resources, 128 KB each and 8 MB per scan — and
+  the captured contents are kept for **one day**, so
+  `test_custom_rule` against an older scan reports no match with nothing
+  left to read.
+
+  Needs the api and crawler sides deployed first.
+
+### Changed
+
+- The internal request-URL rule guard is now a shared pattern-rule guard
+  covering both types, so their contracts cannot drift apart.
+
 ## [0.16.0] - 2026-08-26
 
 ### Added

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { NAME, VERSION, err, ok } from './chunk-LTUO4SP6.js';
+import { NAME, VERSION, err, ok } from './chunk-OX65SNEN.js';
 import process from 'process';
 import { z } from 'zod';
 
@@ -160,10 +160,10 @@ async function main() {
   }
   const config = configResult.value;
   if (config.transport === "stdio") {
-    const { bootstrapStdio } = await import('./stdio-bootstrap-LLCHIZ4X.js');
+    const { bootstrapStdio } = await import('./stdio-bootstrap-NVDBVJ7K.js');
     return bootstrapStdio(config);
   }
-  const { bootstrapHttp } = await import('./http-bootstrap-PDCTS4IS.js');
+  const { bootstrapHttp } = await import('./http-bootstrap-DKGGQURI.js');
   return bootstrapHttp(config);
 }
 main().then(

package/dist/{chunk-YYS2HD6K.js → chunk-FA5A6Y4H.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { err, ok } from './chunk-LTUO4SP6.js';
+import { err, ok } from './chunk-OX65SNEN.js';
 import { createHash, randomUUID } from 'crypto';
 import createClient from 'openapi-fetch';
 import { fetch } from 'undici';
@@ -4223,28 +4223,32 @@ var updateCampaignTool = {
     return ok(result.value);
   }
 };
-var requestUrlRuleConfigSchema = z.object({
-  pattern: z.string().min(1).max(4096).describe("Non-empty request-URL regular expression, at most 4,096 characters."),
+var PATTERN_RULE_TYPES = ["regexp_request_url", "regexp_request_body"];
+var patternRuleConfigSchema = z.object({
+  pattern: z.string().min(1).max(4096).describe("Non-empty regular expression, at most 4,096 characters."),
   flags: z.enum(["", "i"]).optional().describe("Omit or use '' for case-sensitive matching; use 'i' to ignore case.")
 }).strict();
-var REQUEST_URL_RULE_CONFIG_DOC = "For `rule_type='regexp_request_url'`, `config` must be exactly `{ pattern: string, flags?: '' | 'i' }`: pattern is non-empty and at most 4,096 characters; omit flags or use `''` for case-sensitive matching, or `'i'` for case-insensitive matching. `target` must be `'page'`. Fresh scans inspect up to 5,000 captured request URLs. Tests and rechecks of stored scans reconstruct main-frame hops plus up to 200 persisted subrequests with selected resource types omitted, so historical matching is best-effort.";
-function requestUrlRuleInputError(input) {
-  if (input.rule_type !== "regexp_request_url") return null;
+var PATTERN_RULE_CONFIG_DOC = "For `rule_type='regexp_request_url'` and `rule_type='regexp_request_body'`, `config` must be exactly `{ pattern: string, flags?: '' | 'i' }`: pattern is non-empty and at most 4,096 characters; omit flags or use `''` for case-sensitive matching, or `'i'` for case-insensitive matching. `target` must be `'page'` for both. `regexp_request_url` inspects up to 5,000 captured request URLs on a fresh scan; tests and rechecks of stored scans reconstruct main-frame hops plus up to 200 persisted subrequests with selected resource types omitted, so historical matching is best-effort. `regexp_request_body` inspects the CONTENTS of the page's scripts, fetch/XHR responses and iframe documents \u2014 never images, video, fonts or stylesheets \u2014 capped at 400 resources, 128 KB each and 8 MB per scan. Those contents are kept for ONE DAY, so a test or recheck against an older scan reports no match because there is nothing left to read.";
+function isPatternRuleType(ruleType) {
+  return PATTERN_RULE_TYPES.some((known) => known === ruleType);
+}
+function patternRuleInputError(input) {
+  if (!isPatternRuleType(input.rule_type)) return null;
   if (input.target !== void 0 && input.target !== "page") {
     return {
       kind: "invalid-input",
-      message: "regexp_request_url requires target='page'.",
-      fieldErrors: { target: ["Must be 'page' for regexp_request_url."] }
+      message: `${input.rule_type} requires target='page'.`,
+      fieldErrors: { target: [`Must be 'page' for ${input.rule_type}.`] }
     };
   }
-  const parsed = requestUrlRuleConfigSchema.safeParse(input.config);
+  const parsed = patternRuleConfigSchema.safeParse(input.config);
   if (parsed.success) return null;
   const issue = parsed.error.issues[0];
   const field = issue?.path.length ? `config.${issue.path.join(".")}` : "config";
-  const message = issue?.message ?? "Invalid request-URL rule config.";
+  const message = issue?.message ?? "Invalid pattern rule config.";
   return {
     kind: "invalid-input",
-    message: `Invalid regexp_request_url config: ${message}`,
+    message: `Invalid ${input.rule_type} config: ${message}`,
     fieldErrors: { [field]: [message] }
   };
 }
@@ -4260,10 +4264,7 @@ var ruleConfigField = z.record(z.unknown()).superRefine((config, ctx) => {
     });
   }
 });
-var requestUrlAwareRuleConfigField = z.union([
-  requestUrlRuleConfigSchema,
-  ruleConfigField
-]);
+var patternAwareRuleConfigField = z.union([patternRuleConfigSchema, ruleConfigField]);
 
 // src/application/tools/custom-rules/create-custom-rule.tool.ts
 var CreateCustomRuleInputShape = {
@@ -4274,18 +4275,18 @@ var CreateCustomRuleInputShape = {
     "Tag slug to assign on match. Empty = create-only (advanced). The API auto-registers a custom tag definition for this slug with `display_name = name`. **MUST NOT collide with a built-in system tag slug** (see `list_tags` where `scope=system`); colliding requests return 422 with code `checking.system_slug_reserved`. For `rule_type='llm'` use `config.tags` keys instead and leave `tag_slug` empty."
   ),
   rule_type: z.string().max(50).describe(
-    "Rule engine. One of: `stopword_content`, `stopword_url`, `regexp_content`, `regexp_url`, `regexp_request_url`, `blacklist_domain`, `combo`, `llm`. `regexp_url` checks redirect-chain URLs only; `regexp_request_url` checks captured network and subresource URLs. The API validates."
+    "Rule engine. One of: `stopword_content`, `stopword_url`, `regexp_content`, `regexp_url`, `regexp_request_url`, `regexp_request_body`, `blacklist_domain`, `combo`, `llm`. `regexp_url` checks redirect-chain URLs only; `regexp_request_url` checks captured network and subresource URLs; `regexp_request_body` checks what those sub-resources contained. The API validates."
   ),
-  config: requestUrlAwareRuleConfigField.describe(
-    "Rule-type-specific configuration object. Shape depends on `rule_type`. " + REQUEST_URL_RULE_CONFIG_DOC + " `regexp_url` remains redirect-chain-only. For `rule_type='llm'` the shape is `{ prompt: string, tags: { <tag_slug>: <description>, ... } }`; each key in `config.tags` is auto-registered as a custom tag definition AND must not collide with a system slug (same 422 contract as `tag_slug`). " + COMBO_MATCH_SCOPE_DOC
+  config: patternAwareRuleConfigField.describe(
+    "Rule-type-specific configuration object. Shape depends on `rule_type`. " + PATTERN_RULE_CONFIG_DOC + " `regexp_url` remains redirect-chain-only. For `rule_type='llm'` the shape is `{ prompt: string, tags: { <tag_slug>: <description>, ... } }`; each key in `config.tags` is auto-registered as a custom tag definition AND must not collide with a system slug (same 422 contract as `tag_slug`). " + COMBO_MATCH_SCOPE_DOC
   ),
   target: z.string().max(30).optional().describe(
-    "Where to apply the rule (e.g. 'page' for landing HTML). `regexp_request_url` requires `target='page'`. Default: page. See API docs for the full set of valid values."
+    "Where to apply the rule (e.g. 'page' for landing HTML). `regexp_request_url` and `regexp_request_body` require `target='page'`. Default: page. See API docs for the full set of valid values."
   )
 };
 var createCustomRuleTool = {
   name: "create_custom_rule",
-  description: "Define a custom tag-detection rule. Use `rule_type='regexp_request_url'` to match captured network and subresource URLs on the fixed `page` target; fresh scans carry up to 5,000 URLs, while later tests/rechecks use a reduced persisted request tree and are best-effort. `rule_type='regexp_url'` remains redirect-chain-only. The API auto-registers a tag definition for each emitted slug and rejects built-in system-slug collisions with HTTP 422 / `checking.system_slug_reserved`. Matches tag future scans; existing scans are untouched until `recheck_scans`.",
+  description: "Define a custom tag-detection rule. Use `rule_type='regexp_request_url'` to match captured network and subresource URLs on the fixed `page` target; fresh scans carry up to 5,000 URLs, while later tests/rechecks use a reduced persisted request tree and are best-effort. Use `rule_type='regexp_request_body'` to match the CONTENTS of those sub-resources instead \u2014 the right choice when the code you want to catch keeps changing its filename; those contents are kept for one day. `rule_type='regexp_url'` remains redirect-chain-only. The API auto-registers a tag definition for each emitted slug and rejects built-in system-slug collisions with HTTP 422 / `checking.system_slug_reserved`. Matches tag future scans; existing scans are untouched until `recheck_scans`.",
   annotations: {
     title: "Create Custom Rule",
     readOnlyHint: false,
@@ -4295,7 +4296,7 @@ var createCustomRuleTool = {
   },
   inputSchema: z.object(CreateCustomRuleInputShape),
   handler: async (input, ctx) => {
-    const inputError = requestUrlRuleInputError(input);
+    const inputError = patternRuleInputError(input);
     if (inputError) return err(inputError);
     const body = {
       name: input.name,
@@ -4370,19 +4371,19 @@ var listCustomRulesTool = {
 };
 var TestCustomRuleInputShape = {
   rule_type: z.string().max(50).describe(
-    "Rule engine type. One of: `stopword_content`, `stopword_url`, `regexp_content`, `regexp_url`, `regexp_request_url`, `blacklist_domain`, `combo`, `llm`. `regexp_url` checks redirect-chain URLs only; `regexp_request_url` checks captured network and subresource URLs."
+    "Rule engine type. One of: `stopword_content`, `stopword_url`, `regexp_content`, `regexp_url`, `regexp_request_url`, `regexp_request_body`, `blacklist_domain`, `combo`, `llm`. `regexp_url` checks redirect-chain URLs only; `regexp_request_url` checks captured network and subresource URLs; `regexp_request_body` checks what those sub-resources contained."
   ),
-  config: requestUrlAwareRuleConfigField.describe(
-    "Rule-type-specific config to test. Same shape as `create_custom_rule`'s `config`. " + REQUEST_URL_RULE_CONFIG_DOC + " `regexp_url` remains redirect-chain-only. NOTE: `test_custom_rule` evaluates the rule against a scan WITHOUT persisting it, so slug-collision validation does NOT run here \u2014 verify slugs against `list_tags` (`scope=system`) before promoting to `create_custom_rule`. " + COMBO_MATCH_SCOPE_DOC
+  config: patternAwareRuleConfigField.describe(
+    "Rule-type-specific config to test. Same shape as `create_custom_rule`'s `config`. " + PATTERN_RULE_CONFIG_DOC + " `regexp_url` remains redirect-chain-only. NOTE: `test_custom_rule` evaluates the rule against a scan WITHOUT persisting it, so slug-collision validation does NOT run here \u2014 verify slugs against `list_tags` (`scope=system`) before promoting to `create_custom_rule`. " + COMBO_MATCH_SCOPE_DOC
   ),
   target: z.string().max(30).describe(
-    "Where to apply the rule (e.g. 'page' for landing HTML). `regexp_request_url` requires `target='page'`. See API docs for the full set of valid values."
+    "Where to apply the rule (e.g. 'page' for landing HTML). `regexp_request_url` and `regexp_request_body` require `target='page'`. See API docs for the full set of valid values."
   ),
   scan_id: z.string().uuid().describe("Existing scan UUID to evaluate the rule against.")
 };
 var testCustomRuleTool = {
   name: "test_custom_rule",
-  description: "Preview-test a rule definition against a stored scan without persisting it. For `regexp_request_url`, the historical snapshot contains main-frame hops plus at most 200 persisted subrequests with selected resource types omitted, so a no-match does not prove the original fresh scan lacked the request. Returns match state, elapsed time, and per-tag detail; the preview response does not expose the matched request URL separately. Slug-collision validation does not run in preview mode.",
+  description: "Preview-test a rule definition against a stored scan without persisting it. For `regexp_request_url`, the historical snapshot contains main-frame hops plus at most 200 persisted subrequests with selected resource types omitted, so a no-match does not prove the original fresh scan lacked the request. For `regexp_request_body`, the captured contents live for ONE DAY \u2014 pick a scan from the last 24 hours, because an older one reports no match with nothing left to read. Returns match state, elapsed time, and per-tag detail; the preview response does not expose the matched request URL separately. Slug-collision validation does not run in preview mode.",
   annotations: {
     title: "Test Custom Rule",
     readOnlyHint: true,
@@ -4392,7 +4393,7 @@ var testCustomRuleTool = {
   },
   inputSchema: z.object(TestCustomRuleInputShape),
   handler: async (input, ctx) => {
-    const inputError = requestUrlRuleInputError(input);
+    const inputError = patternRuleInputError(input);
     if (inputError) return err(inputError);
     const result = await ctx.api.testCustomRule({
       rule_type: input.rule_type,
@@ -4412,17 +4413,17 @@ var UpdateCustomRuleInputShape = {
   tag_slug: z.string().max(100).optional().describe(
     "New tag slug to assign on match. **MUST NOT collide with a built-in system tag slug** (see `list_tags` where `scope=system`); colliding requests return 422 with code `checking.system_slug_reserved`. Leaving a GLOBAL rule on the same slug preserves its admin-managed tag metadata."
   ),
-  config: requestUrlAwareRuleConfigField.optional().describe(
-    "New rule-type-specific config object. Replaces the stored config wholesale \u2014 resend every key you want to keep, including a combo rule's `match_scope`. For `rule_type='llm'` the keys of `config.tags` are auto-registered as tag definitions; any key that collides with a system slug returns the same 422 contract. " + REQUEST_URL_RULE_CONFIG_DOC + " Read the rule first because `rule_type` is immutable and is not repeated in this update input. " + COMBO_MATCH_SCOPE_DOC
+  config: patternAwareRuleConfigField.optional().describe(
+    "New rule-type-specific config object. Replaces the stored config wholesale \u2014 resend every key you want to keep, including a combo rule's `match_scope`. For `rule_type='llm'` the keys of `config.tags` are auto-registered as tag definitions; any key that collides with a system slug returns the same 422 contract. " + PATTERN_RULE_CONFIG_DOC + " Read the rule first because `rule_type` is immutable and is not repeated in this update input. " + COMBO_MATCH_SCOPE_DOC
   ),
   target: z.string().max(30).optional().describe(
-    "Where to apply the rule. `regexp_request_url` is fixed to `page`; do not change it. See API docs for the valid targets of other rule types."
+    "Where to apply the rule. `regexp_request_url` and `regexp_request_body` are fixed to `page`; do not change it. See API docs for the valid targets of other rule types."
   ),
   is_active: z.boolean().optional().describe("Enable/disable the rule.")
 };
 var updateCustomRuleTool = {
   name: "update_custom_rule",
-  description: "Update a custom tag-detection rule. Only supplied fields are sent, but `config` replaces the stored object wholesale; read the rule first and resend every required key. `regexp_request_url` needs a non-empty pattern (max 4,096), flags `''`/`'i'`, and the fixed `page` target. Same-slug GLOBAL rule edits preserve separately managed tag metadata; use `update_tag_definition` to change it. Existing scans are not re-evaluated until `recheck_scans`.",
+  description: "Update a custom tag-detection rule. Only supplied fields are sent, but `config` replaces the stored object wholesale; read the rule first and resend every required key. `regexp_request_url` and `regexp_request_body` need a non-empty pattern (max 4,096), flags `''`/`'i'`, and the fixed `page` target. Same-slug GLOBAL rule edits preserve separately managed tag metadata; use `update_tag_definition` to change it. Existing scans are not re-evaluated until `recheck_scans`.",
   annotations: {
     title: "Update Custom Rule",
     readOnlyHint: false,
@@ -6226,5 +6227,5 @@ function formatToolError(error) {
 }
 
 export { BearerToken, SERVER_INSTRUCTIONS, createHttpApiGateway, createPinoLogger, declareEmptyResourcesAndPrompts, newRequestId, wireToolsIntoMcpServer };
-//# sourceMappingURL=chunk-YYS2HD6K.js.map
-//# sourceMappingURL=chunk-YYS2HD6K.js.map
+//# sourceMappingURL=chunk-FA5A6Y4H.js.map
+//# sourceMappingURL=chunk-FA5A6Y4H.js.map