agent-first-data 0.34.0 → 0.35.1

package/README.md

@@ -22,11 +22,11 @@ Useful names use TypeScript casing: `render`, `outputOptionsForPolicy`, `redacte
 ## Behavior Notes
 
 - Default redaction replaces every `_secret` or configured secret-name subtree with `***`, including objects and arrays.
-- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed and internal whitespace redacts the whole field.
+- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed, and internal whitespace or a `://` that is not the start of a clean URL redacts the whole field, where whitespace is the explicit Unicode `White_Space` set the spec enumerates, not the language's native predicate.
 - `OutputOptions.redaction.urlNames` applies URL treatment to exact legacy field names
   and recurses through collections. `redactUrlsInText` is explicit and scans
   only complete scheme URLs, never arbitrary prose secrets.
-- YAML keeps original keys and values (structure-preserving, like JSON), sorting keys by UTF-16 code unit order and quoting/escaping unsafe keys and string scalars. Plain strips formatting suffixes, formats values, sorts the same way, and renders nested objects/arrays as canonical JSON.
+- YAML keeps original keys and values (structure-preserving, like JSON), sorting keys by UTF-16 code unit order and quoting/escaping unsafe keys and string scalars. Plain strips formatting suffixes, formats values, sorts the same way, and renders nested objects/arrays as canonical JSON; it quotes a value only when it contains ASCII space, tab, newline, carriage return, form feed, vertical tab, NBSP, `=`, `"`, or `\`, and escapes `\`, `"`, newline, carriage return, tab, form feed, and vertical tab inside the quotes.
 - Logging records use `kind:"log"` with a nested `log` payload and a separate `level` field, so error-level logs are not terminal protocol errors.
 - `buildCliError(message, hint?)` returns a strict-ready CLI error with `error.retryable:false` and `trace:{}`.
 - Do not add a raw version/help pre-parser. Until the TypeScript `CliSpec` compiler lands, applications should keep lifecycle parsing in their own parser rather than claim AFDATA closed-world help compatibility.

package/dist/cli.js

@@ -110,8 +110,19 @@ export function parseOutputTo(value) {
     }
     throw new Error("invalid --output-to: expected split, stdout, or stderr");
 }
+const guardedProcessStreams = new WeakSet();
+function guardProcessStream(stream) {
+    if (guardedProcessStreams.has(stream))
+        return;
+    guardedProcessStreams.add(stream);
+    stream.on("error", (error) => {
+        if (error.code !== "EPIPE")
+            throw error;
+    });
+}
 /** Event writer bound to the process stdout stream. */
 const processStdoutWriter = (line) => {
+    guardProcessStream(process.stdout);
     process.stdout.write(line);
 };
 /**
@@ -121,6 +132,7 @@ const processStdoutWriter = (line) => {
  * `stderr-sink` marker is what no_stderr_policy.test.ts allows through.
  */
 const processStderrWriter = (line) => {
+    guardProcessStream(process.stderr); // stderr-sink: CliEmitter diagnostic channel
     process.stderr.write(line); // stderr-sink: CliEmitter diagnostic channel
 };
 /**

package/dist/format.js

@@ -869,7 +869,7 @@ function applyRedactionPolicyWithContext(value, redactionPolicy, context) {
  * when s is a processable URL, or null when it is not (so callers can keep the
  * original). Only secret spans change; all other bytes are preserved.
  */
-function redactUrlInStr(s, secretNames) {
+function redactUrlInStr(s, secretNames, depth = 0) {
     // Precondition (spec): a single, whitespace-free, scheme-prefixed URL.
     // The gate is scheme + no-whitespace only — NOT "parses via `new URL`". Span
     // location below is purely byte-wise (we never re-serialize the URL), so a
@@ -879,6 +879,9 @@ function redactUrlInStr(s, secretNames) {
     if (!s.includes("://") || !isSingleUrl(s)) {
         return null;
     }
+    // Bound recursive redirect inspection, failing closed before stack growth.
+    if (depth >= 16)
+        return REDACTED_MARKER;
     const schemeSep = s.indexOf("://");
     const scheme = s.slice(0, schemeSep);
     const rest = s.slice(schemeSep + 3);
@@ -891,8 +894,31 @@ function redactUrlInStr(s, secretNames) {
             break;
         }
     }
+    // An unencoded '?' or '#' inside a password ends that authority early and
+    // leaves the rest of the password in the query or fragment. When a ':'
+    // precedes that early end and an '@' follows it before the first '/', the
+    // userinfo runs to that '@' — how libpq reads such a connection string.
+    const slash = rest.indexOf("/");
+    const firstSlash = slash < 0 ? rest.length : slash;
+    const at = rest.slice(0, firstSlash).lastIndexOf("@");
+    if (rest.slice(0, authEnd).includes(":") && at > authEnd) {
+        authEnd = rest.length;
+        for (let i = at; i < rest.length; i++) {
+            const c = rest[i];
+            if (c === "/" || c === "?" || c === "#") {
+                authEnd = i;
+                break;
+            }
+        }
+    }
     const authority = rest.slice(0, authEnd);
     const remainder = rest.slice(authEnd);
+    // An unencoded '/' inside a password ends the authority at a "port" that is
+    // not a number, with the '@' somewhere after it. Where the password ends
+    // cannot be known, so the whole value is replaced.
+    if (!authority.includes("@") && hasNonNumericPort(authority) && remainder.includes("@")) {
+        return REDACTED_MARKER;
+    }
     const newAuthority = redactUserinfoPassword(authority);
     // `remainder` is `path[?query][#fragment]`; '#' ends the query, so split the
     // fragment off first and the query out of what is left.
@@ -901,14 +927,26 @@ function redactUrlInStr(s, secretNames) {
     const fragment = hash >= 0 ? remainder.slice(hash + 1) : null;
     const q = beforeFragment.indexOf("?");
     const newBeforeFragment = q >= 0
-        ? `${beforeFragment.slice(0, q)}?${redactQuery(beforeFragment.slice(q + 1), secretNames)}`
+        ? `${beforeFragment.slice(0, q)}?${redactQuery(beforeFragment.slice(q + 1), secretNames, depth)}`
         : beforeFragment;
     // A fragment gets the same treatment as the query: `k=v&k=v` after the '#' is
     // exactly how an OAuth implicit-flow response hands back a token, so a
     // secret-named fragment parameter must not survive where the identically
     // named query parameter would not. A fragment that is not in that shape has
     // no '=' in its segments and passes through byte-for-byte.
-    const newFragment = fragment === null ? "" : `#${redactQuery(fragment, secretNames)}`;
+    // A hash route (`#/cb?k=v`) carries its parameters after its first '?',
+    // while a form reader keeps that '?' inside a value; redact both readings:
+    // the fragment as parameters first, so a secret value absorbs its '?',
+    // then whatever follows the first '?' that survives.
+    let newFragment = "";
+    if (fragment !== null) {
+        const params = redactQuery(fragment, secretNames, depth);
+        const routeQuery = params.indexOf("?");
+        newFragment =
+            routeQuery >= 0
+                ? `#${params.slice(0, routeQuery)}?${redactQuery(params.slice(routeQuery + 1), secretNames, depth)}`
+                : `#${params}`;
+    }
     return `${scheme}://${newAuthority}${newBeforeFragment}${newFragment}`;
 }
 function redactUrlsInTextWithContext(text, context) {
@@ -1029,19 +1067,28 @@ function redactUrlFieldValue(s, secretNames) {
     const redacted = redactUrlInStr(s, secretNames);
     if (redacted !== null)
         return redacted;
-    const trimmed = s.trim();
+    let start = 0;
+    let end = s.length;
+    while (start < end && isSpanTerminatorWhitespace(s.charCodeAt(start)))
+        start += 1;
+    while (end > start && isSpanTerminatorWhitespace(s.charCodeAt(end - 1)))
+        end -= 1;
+    const trimmed = s.slice(start, end);
     if (trimmed !== s) {
         const trimmedRedacted = redactUrlInStr(trimmed, secretNames);
         if (trimmedRedacted !== null)
             return trimmedRedacted;
     }
     // Fail closed: a _url value we could not parse as a clean scheme-prefixed
-    // URL, yet which carries a credential sigil ('@' userinfo) or internal
-    // whitespace, is redacted wholesale rather than passed through. A schemeless
-    // connection string like user:pass@host/db has no scheme anchor for the
-    // surgical span logic above, so blanket redaction is the safe default.
-    if (/\s/.test(s) || s.includes("@"))
+    // URL, yet which carries a credential sigil ('@' userinfo), internal
+    // whitespace, or a '://' scheme separator, is redacted wholesale rather than
+    // passed through. A schemeless connection string like user:pass@host/db
+    // has no scheme anchor for the surgical span logic above, and a URL behind
+    // a non-whitespace prefix (a BOM, a zero-width space, a label) has one the
+    // span logic cannot reach, so blanket redaction is the safe default.
+    if ([...s].some(c => isSpanTerminatorWhitespace(c.charCodeAt(0))) || s.includes("@") || s.includes("://")) {
         return REDACTED_MARKER;
+    }
     return s;
 }
 /**
@@ -1062,7 +1109,7 @@ function redactUserinfoPassword(authority) {
  * Redact the values of secret-named query parameters, preserving raw bytes of
  * every other segment (keys, benign values, encoding, ordering, separators).
  */
-function redactQuery(query, secretNames) {
+function redactQuery(query, secretNames, depth) {
     return query
         .split("&")
         .map((segment) => {
@@ -1074,19 +1121,33 @@ function redactQuery(query, secretNames) {
         if (isSecretKey(name, secretNames)) {
             return `${rawKey}=${REDACTED_MARKER}`;
         }
+        // A redirect target carries its own parameters: redact a nested URL in
+        // place, or the whole value when it arrived encoded.
+        const rawValue = segment.slice(eq + 1);
+        const value = formDecode(rawValue);
+        const redacted = redactUrlInStr(value, secretNames, depth + 1);
+        if (redacted !== null && redacted !== value) {
+            return value === rawValue ? `${rawKey}=${redacted}` : `${rawKey}=${REDACTED_MARKER}`;
+        }
         return segment;
     })
         .join("&");
 }
-/** Form-decode a query-parameter name: '+' → space, then percent-decode. */
+/**
+ * True when the authority's text after its last ':' is not a port number. A
+ * bracketed IPv6 literal without a port ends in ']' and has none.
+ */
+function hasNonNumericPort(authority) {
+    const colon = authority.lastIndexOf(":");
+    if (colon < 0 || authority.endsWith("]"))
+        return false;
+    return !/^[0-9]*$/.test(authority.slice(colon + 1));
+}
+/** Form-decode a query-parameter name or value: '+' → space, then percent-decode. */
 function formDecode(rawKey) {
-    const withSpaces = rawKey.replace(/\+/g, " ");
-    try {
-        return decodeURIComponent(withSpaces);
-    }
-    catch {
-        return withSpaces;
-    }
+    // URLSearchParams keeps malformed escapes literal and replaces invalid
+    // UTF-8, while still decoding valid escapes elsewhere in the value.
+    return new URLSearchParams(`value=${rawKey.replace(/&/g, "%26")}`).get("value") ?? "";
 }
 /**
  * True when s begins with a URL scheme (ALPHA *(ALPHA / DIGIT / "+" / "-" /
@@ -1173,28 +1234,30 @@ function decimalIntText(value) {
 }
 const MIN_I64 = -9223372036854775808n;
 const MAX_I64 = 9223372036854775807n;
-function signedI64(value) {
-    let text = null;
-    if (typeof value === "bigint") {
-        text = value.toString();
-    }
-    else if (typeof value === "number" && Number.isSafeInteger(value)) {
-        text = String(value);
-    }
-    else if (isLosslessNumber(value)) {
+const MAX_U64 = 18446744073709551615n;
+// An integer literal stays exact; a decoded integral float (`3.0`) counts as
+// an integer like any other.
+function integerValue(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return Number.isInteger(value) ? BigInt(value) : null;
+    if (isLosslessNumber(value)) {
         const literal = value.toString();
         if (/^-?\d+$/.test(literal))
-            text = literal;
-    }
-    if (text === null)
-        return null;
-    try {
-        const integer = BigInt(text);
-        return integer >= MIN_I64 && integer <= MAX_I64 ? integer : null;
-    }
-    catch {
-        return null;
+            return BigInt(literal);
+        const parsed = Number(literal);
+        return Number.isInteger(parsed) ? BigInt(parsed) : null;
     }
+    return null;
+}
+function signedI64(value) {
+    const integer = integerValue(value);
+    return integer !== null && integer >= MIN_I64 && integer <= MAX_I64 ? integer : null;
+}
+function unsignedU64(value) {
+    const integer = integerValue(value);
+    return integer !== null && integer >= 0n && integer <= MAX_U64 ? integer : null;
 }
 function formatCents(value, symbol) {
     const sign = value < 0n ? "-" : "";
@@ -1346,8 +1409,9 @@ function tryProcessField(key, value) {
     }
     stripped = stripSuffixCI(key, "_bytes");
     if (stripped !== null) {
-        if (isInt(numeric) && numeric >= 0)
-            return [stripped, formatBytesHuman(numeric)];
+        const bytes = unsignedU64(value);
+        if (bytes !== null)
+            return [stripped, formatBytesHuman(Number(bytes))];
         return null;
     }
     stripped = stripSuffixCI(key, "_percent");
@@ -1629,7 +1693,8 @@ function isAmbiguousYamlKey(key) {
     if (["true", "false", "null", "~", ".nan", ".inf", "+.inf", "-.inf"].includes(key.toLowerCase())) {
         return true;
     }
-    return key.trim() !== "" && Number.isFinite(Number(key));
+    return ["inf", "infinity", "nan"].includes(key.replace(/^[+-]/, "").toLowerCase())
+        || /^[-+]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][-+]?[0-9]+)?$/.test(key);
 }
 function yamlScalar(value) {
     if (typeof value === "string")
@@ -1726,7 +1791,7 @@ function plainScalarRaw(value) {
 function quoteLogfmtValue(value) {
     if (value === "")
         return "";
-    if (!/[\s="\\]/.test(value))
+    if (!/[ \t\n\r\f\v\u00a0="\\]/.test(value))
         return value;
     const escaped = value
         .replace(/\\/g, "\\\\")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-first-data",
-  "version": "0.34.0",
+  "version": "0.35.1",
   "description": "A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading Markdown structure and safely editing structured JSON, TOML, YAML, dotenv, and INI documents.",
   "license": "MIT",
   "repository": {
@@ -27,11 +27,11 @@
     "test": "tsx --test src/*.test.ts"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
-    "tsx": "^4.23.12",
+    "@types/node": "^26.6.5",
+    "tsx": "^4.23.15",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "lossless-json": "^4.3.1"
+    "lossless-json": "^4.3.3"
   }
 }