mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 19:53:50 +00:00
rea-agents 6.9.0 advertised `^[^\uD800-\uDFFF]*$` on every local path input. RE2 has no `\u` escape and Rust's `regex`/`jsonschema` crates refuse non-scalar code points, so strict MCP clients and gateways (DeepSeek, RE2 gateways, Open Design) rejected the complete tools request and no REA tool could run. Move the rule into one runtime check, `rejectUnpairedSurrogates`, which advertises nothing and still raises the `invalid_format` regex issue, so CLI and MCP corrections keep reason, expected value, and message. The objdump disassembly symbol already enforced the same rule with its own refinement; it now shares the owner and the correction shape. Dropping the pattern also brings inspect_android_jni_bindings within the compact profile's per-schema budget, so compact delivery now keeps its DEX dimension pattern. The descriptor admission test follows the actual presentation instead of assuming compact always omits it. Fixes #10238 Fixes #10348 Fixes #10198 Co-Authored-By: gensokyo-dev <gensokyo-dev@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
177 lines
5.2 KiB
TypeScript
177 lines
5.2 KiB
TypeScript
import { Ajv2020 } from "ajv/dist/2020.js";
|
|
import { expect, it } from "vitest";
|
|
import { z } from "zod";
|
|
|
|
import {
|
|
BASE64_QUARTET_LENGTH_PATTERN,
|
|
INVALID_BASE64_CHARACTER_PATTERN,
|
|
INVALID_BASE64_PADDING_PATTERN,
|
|
INVALID_CANONICAL_BASE64_PAD_BITS_PATTERN,
|
|
IDENTIFIER_PATTERN,
|
|
STABLE_IDENTIFIER_PATTERN,
|
|
canonicalBase64Schema,
|
|
isCanonicalBase64,
|
|
isPaddedBase64,
|
|
rejectUnpairedSurrogates,
|
|
} from "./stringPatterns.js";
|
|
|
|
it("preserves identifier grammars under Unicode and Unicode-set compilation", () => {
|
|
const variants = [
|
|
{ pattern: IDENTIFIER_PATTERN, previous: /^[A-Za-z][A-Za-z0-9._-]*$/u },
|
|
{
|
|
pattern: STABLE_IDENTIFIER_PATTERN,
|
|
previous: /^[A-Za-z][A-Za-z0-9._:/-]*$/u,
|
|
},
|
|
];
|
|
const samples = [
|
|
"",
|
|
"a",
|
|
"A",
|
|
"_id",
|
|
"1id",
|
|
"é",
|
|
"aé",
|
|
"a/b:c",
|
|
"a-b.c_1",
|
|
"a\n",
|
|
"a\\b",
|
|
];
|
|
for (let code = 0; code < 128; code += 1) {
|
|
const character = String.fromCharCode(code);
|
|
samples.push(character, `A${character}`, `A${character}B`);
|
|
}
|
|
for (const { pattern, previous } of variants) {
|
|
for (const flag of ["u", "v"]) {
|
|
const projected = new RegExp(pattern.source, flag);
|
|
for (const sample of samples)
|
|
expect(projected.test(sample), JSON.stringify({ flag, sample })).toBe(
|
|
previous.test(sample),
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
it("preserves canonical and permissive padded base64 validation", () => {
|
|
const previous =
|
|
/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$/;
|
|
const samples = [
|
|
"",
|
|
"AA==",
|
|
"AB==",
|
|
"AAA=",
|
|
"AAB=",
|
|
"////",
|
|
"A",
|
|
"AA",
|
|
"AAA",
|
|
"====",
|
|
"AA==\n",
|
|
"AA==\r\n",
|
|
"AA==\u2028",
|
|
"AA==\u2029",
|
|
"AA\nAA",
|
|
"AA=\n=",
|
|
"AA-_",
|
|
"a b c",
|
|
];
|
|
const alphabet =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
for (const first of alphabet)
|
|
for (const second of alphabet)
|
|
samples.push(`${first}${second}==`, `A${first}${second}=`);
|
|
for (const sample of samples) {
|
|
expect(isCanonicalBase64(sample), JSON.stringify({ sample })).toBe(
|
|
previous.test(sample),
|
|
);
|
|
expect(isPaddedBase64(sample), JSON.stringify({ sample })).toBe(
|
|
sample.length % 4 === 0 && /^[A-Za-z0-9+/]*(?:==|=)?$/.test(sample),
|
|
);
|
|
}
|
|
});
|
|
|
|
it("advertises every portable base64 constraint and keeps large inputs stack-safe", () => {
|
|
const jsonSchema = z.toJSONSchema(canonicalBase64Schema, {
|
|
target: "draft-2020-12",
|
|
});
|
|
expect(jsonSchema).toMatchObject({
|
|
allOf: expect.arrayContaining([
|
|
{ pattern: BASE64_QUARTET_LENGTH_PATTERN.source },
|
|
{ not: { pattern: INVALID_BASE64_CHARACTER_PATTERN.source } },
|
|
{ not: { pattern: INVALID_BASE64_PADDING_PATTERN.source } },
|
|
{ not: { pattern: INVALID_CANONICAL_BASE64_PAD_BITS_PATTERN.source } },
|
|
]),
|
|
});
|
|
|
|
const body = Buffer.alloc(24 * 1024 * 1024 - 3, 0x81);
|
|
const encoded = body.toString("base64");
|
|
for (const flag of ["", "u", "v"]) {
|
|
expect(
|
|
new RegExp(BASE64_QUARTET_LENGTH_PATTERN.source, flag).test(encoded),
|
|
flag,
|
|
).toBe(true);
|
|
expect(
|
|
new RegExp(INVALID_BASE64_CHARACTER_PATTERN.source, flag).test(encoded),
|
|
flag,
|
|
).toBe(false);
|
|
expect(
|
|
new RegExp(INVALID_BASE64_PADDING_PATTERN.source, flag).test(encoded),
|
|
flag,
|
|
).toBe(false);
|
|
expect(
|
|
new RegExp(INVALID_CANONICAL_BASE64_PAD_BITS_PATTERN.source, flag).test(
|
|
encoded,
|
|
),
|
|
flag,
|
|
).toBe(false);
|
|
expect(
|
|
new RegExp(INVALID_BASE64_CHARACTER_PATTERN.source, flag).test(
|
|
`${encoded.slice(0, -1)}!`,
|
|
),
|
|
flag,
|
|
).toBe(true);
|
|
expect(
|
|
new RegExp(INVALID_CANONICAL_BASE64_PAD_BITS_PATTERN.source, flag).test(
|
|
`${encoded.slice(0, -3)}R==`,
|
|
),
|
|
flag,
|
|
).toBe(true);
|
|
}
|
|
expect(isCanonicalBase64(encoded)).toBe(true);
|
|
});
|
|
|
|
it("validates complete projected canonical schemas at the encoded-input budget", () => {
|
|
const projected = z.toJSONSchema(canonicalBase64Schema, {
|
|
target: "draft-2020-12",
|
|
});
|
|
const validate = new Ajv2020({ strict: true }).compile(projected);
|
|
const encoded = Buffer.alloc(24 * 1024 * 1024 - 3, 0x81).toString("base64");
|
|
for (const { value, expected } of [
|
|
{ value: encoded, expected: true },
|
|
{ value: `${encoded.slice(0, -1)}!`, expected: false },
|
|
{ value: `${encoded.slice(0, -3)}R==`, expected: false },
|
|
{ value: `${encoded}A`, expected: false },
|
|
]) {
|
|
expect(canonicalBase64Schema.safeParse(value).success).toBe(expected);
|
|
expect(validate(value)).toBe(expected);
|
|
}
|
|
});
|
|
|
|
it("rejects unpaired surrogates at runtime without advertising a pattern", () => {
|
|
const schema = rejectUnpairedSurrogates(z.string(), "Must be well-formed");
|
|
for (const value of ["\ud800", "a\udc00", "\udc00\ud800", "\ud83d"])
|
|
expect(
|
|
schema.safeParse(value).error?.issues,
|
|
JSON.stringify(value),
|
|
).toEqual([
|
|
{
|
|
code: "invalid_format",
|
|
format: "regex",
|
|
message: "Must be well-formed",
|
|
path: [],
|
|
},
|
|
]);
|
|
for (const value of ["", "plain", "\ud83d\ude00", "\ufffd", "\uffff"])
|
|
expect(schema.safeParse(value).success, JSON.stringify(value)).toBe(true);
|
|
expect(z.toJSONSchema(schema, { io: "input" })).not.toHaveProperty("pattern");
|
|
});
|