@sema-agent/server 7.87.3 → 7.88.0

package/dist/trace/redact.js

@@ -591,11 +591,28 @@ const keywordArm = (keywordSrc, valueClass, min, tailSrc = "") => {
         `|(?<!${WORD_SEGMENT_CLASS})${keywordSrc}(?:${twoStrongAhead(valueClass)}|${noConnectorAhead(valueClass)})${atLeast(valueClass, min)}${tailSrc})`, "g");
     return re;
 };
+const CREDENTIAL_NAME_WORDS = [
+    "api_key", "apikey", "api-key", "key",
+    "token", "access_token", "refresh_token", "id_token",
+    "auth", "authorization",
+    "password", "passwd", "pwd",
+    "secret", "client_secret", "private_key",
+    "signature", "sig",
+    "x-amz-signature", "x-amz-security-token", "x-amz-credential",
+    "sas",
+];
+const CREDENTIAL_NAME_ALT = (() => {
+    for (const w of CREDENTIAL_NAME_WORDS) {
+        if (!/^[a-z][a-z0-9_-]*$/.test(w))
+            throw new Error(`redact: credential name ${JSON.stringify(w)} must be lowercase [a-z0-9_-] (the alternation is built without escaping)`);
+    }
+    return [...CREDENTIAL_NAME_WORDS].sort((a, b) => b.length - a.length || (a < b ? -1 : 1)).join("|");
+})();
 const STRUCTURAL_SECRET_PATTERNS = [
     [/-----BEGIN(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----[\s\S]{0,8192}?-----END(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----/g, "«redacted:private-key»"],
     [/---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----[\s\S]{0,8192}?---- END SSH2 ENCRYPTED PRIVATE KEY ----/g, "«redacted:private-key»"],
-    [/:(?<=[A-Za-z][A-Za-z0-9+.-]*:)\/\//g, "$1:«redacted»@"],
-    [/("(?:private_key|client_secret|password|api[_-]?key|secret|token)"\s*:\s*)"[^"\\]*(?:\\.[^"\\]*)*"/gi, '$1"«redacted»"'],
+    [/:(?<=[A-Za-z][A-Za-z0-9+.-]*:)\/\//g, "$1«redacted»"],
+    [new RegExp(String.raw `("(?:${CREDENTIAL_NAME_ALT})"\s*:\s*)"[^"\\]*(?:\\.[^"\\]*)*"`, "gi"), '$1"«redacted»"'],
 ];
 const PPK_CONTAINER_TOKEN = "«redacted:private-key»";
 const PEM_FRAGMENT_TOKEN = "«redacted:private-key:partial»";
@@ -1067,7 +1084,8 @@ const FRAGMENT_SECRET_PATTERNS = [
     [valueArm("(?:gl(?:pat|dt|rt|rtr|cbt|ptt|oas|ft|imt|agent|wt|soat|ffct)-|(?:sk|rk)_(?:live|test|org)_|pypi-)", "[A-Za-z0-9_-]", 8, "needs-left-boundary"), "«redacted:key:partial»"],
     [valueArm("xapp-\\d-", "[A-Za-z0-9-]", 4, "needs-left-boundary"), "«redacted:slack-token:partial»"],
 ];
-const REDACTION_TOKENS = new Set([...FULL_ARM_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
+const DISPLAY_SAFE_URL_TOKEN = "«redacted:url»";
+const REDACTION_TOKENS = new Set([...FULL_ARM_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, DISPLAY_SAFE_URL_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
     .flatMap((r) => r.match(/«[^»]*»/g) ?? []));
 {
     const closed = new RegExp(`^${REDACTION_TOKEN_RE_SRC}$`);
@@ -1091,11 +1109,11 @@ const FRAGMENT_ARM_TOKENS = new Set(FRAGMENT_SECRET_PATTERNS.map(([, repl]) => r
 }
 const armOfToken = (repl) => (FRAGMENT_ARM_TOKENS.has(repl) ? "fragment" : "full");
 const NO_HITS = [];
-const URL_USERINFO_PATTERN = (() => {
-    const row = FULL_ARM_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
-    if (row === undefined)
-        throw new Error("redact: URL-userinfo rule missing from FULL_ARM_PATTERNS");
-    return row;
+const URL_CREDENTIAL_PATTERN = (() => {
+    const rows = FULL_ARM_PATTERNS.filter(([, repl]) => repl === "$1«redacted»");
+    if (rows.length !== 1)
+        throw new Error(`redact: expected exactly one URL-credential rule (replacement "$1«redacted»") in FULL_ARM_PATTERNS, found ${rows.length}`);
+    return rows[0];
 })();
 const SSH2_FENCE_PATTERN = (() => {
     const row = FULL_ARM_PATTERNS.find(([re]) => re.source.startsWith(SSH2_FENCE_OPEN));
@@ -1105,7 +1123,51 @@ const SSH2_FENCE_PATTERN = (() => {
 })();
 const isRegexSpace = (c) => c === 32 || (c >= 9 && c <= 13) || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a) || c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;
 const isLineTerminator = (c) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029;
+const isControlCode = (c) => c < 0x20 || c === 0x7f;
 const TOKEN_UNIT_Y = new RegExp(REDACTION_TOKEN_RE_SRC, "y");
+const CREDENTIAL_PARAM_Y = new RegExp(`(?:${CREDENTIAL_NAME_ALT})=`, "iy");
+const CREDENTIAL_NAME_SET = new Set(CREDENTIAL_NAME_WORDS);
+const CREDENTIAL_NAME_SCAN_MAX = Math.max(...CREDENTIAL_NAME_WORDS.map((w) => w.length)) * 3 + 1;
+function decodeAsciiName(name) {
+    let out = "";
+    for (let i = 0; i < name.length; i++) {
+        const c = name.charCodeAt(i);
+        if (c !== 37) {
+            out += name[i];
+            continue;
+        }
+        const hex = name.slice(i + 1, i + 3);
+        if (hex.length !== 2 || !/^[0-9A-Fa-f]{2}$/.test(hex))
+            return undefined;
+        const b = Number.parseInt(hex, 16);
+        if (b >= 0x80)
+            return undefined;
+        out += String.fromCharCode(b);
+        i += 2;
+    }
+    return out;
+}
+function credentialParamValueStart(text, p) {
+    CREDENTIAL_PARAM_Y.lastIndex = p;
+    if (CREDENTIAL_PARAM_Y.test(text))
+        return CREDENTIAL_PARAM_Y.lastIndex;
+    const limit = Math.min(text.length, p + CREDENTIAL_NAME_SCAN_MAX);
+    let hasPct = false;
+    for (let i = p; i < limit; i++) {
+        const c = text.charCodeAt(i);
+        if (c === 37) {
+            hasPct = true;
+            continue;
+        }
+        if (c !== CH_EQ)
+            continue;
+        if (!hasPct)
+            return -1;
+        const decoded = decodeAsciiName(text.slice(p, i));
+        return decoded !== undefined && CREDENTIAL_NAME_SET.has(decoded.toLowerCase()) ? i + 1 : -1;
+    }
+    return -1;
+}
 function tokenUnitEnd(text, p) {
     TOKEN_UNIT_Y.lastIndex = p;
     return TOKEN_UNIT_Y.test(text) ? TOKEN_UNIT_Y.lastIndex : -1;
@@ -1195,8 +1257,10 @@ function opaqueUnitEnd(p) {
     scanEvidenceCursor = k;
     return k < st.length && st[k] === p ? scanEvidence.ends[k] : -1;
 }
-function scanUserinfoRun(text, i, kind, json) {
+let lastAtInRun = -1;
+function scanUrlRun(text, i, kind, json) {
     const n = text.length;
+    lastAtInRun = -1;
     while (i < n) {
         const unit = opaqueUnitEnd(i);
         if (unit >= 0) {
@@ -1211,11 +1275,11 @@ function scanUserinfoRun(text, i, kind, json) {
             }
             return i;
         }
-        if (c === 64 || isRegexSpace(c) || (json && c === 34))
+        if (isRegexSpace(c) || (json && c === 34))
             return i;
         switch (kind) {
             case "plain-user":
-                if (c === 47 || c === 58)
+                if (c === CH_AT || c === 47 || c === 58)
                     return i;
                 break;
             case "plain-pass":
@@ -1226,33 +1290,50 @@ function scanUserinfoRun(text, i, kind, json) {
                 if (c === 58 && text.charCodeAt(i + 1) === 47 && text.charCodeAt(i + 2) === 47)
                     return i;
                 break;
+            case "param-value":
+                if (c === 38 || c === 35 || isControlCode(c))
+                    return i;
+                break;
         }
+        if (c === CH_AT)
+            lastAtInRun = i;
         i += 1;
     }
     return i;
 }
 function matchUserinfoAt(text, p, json) {
-    const userEnd = scanUserinfoRun(text, p, "plain-user", json);
-    if (text.charCodeAt(userEnd) !== 58)
-        return null;
-    const keyId = userEnd > p && credentialSpansCover(scanEvidence, p, userEnd);
-    const passEnd = scanUserinfoRun(text, userEnd + 1, keyId ? "token-pass" : "plain-pass", json);
-    if (passEnd === userEnd + 1 || text.charCodeAt(passEnd) !== 64)
+    const probeEnd = scanUrlRun(text, p, "plain-user", json);
+    const keyId = probeEnd > p && text.charCodeAt(probeEnd) === 58 && credentialSpansCover(scanEvidence, p, probeEnd);
+    scanUrlRun(text, p, keyId ? "token-pass" : "plain-pass", json);
+    if (lastAtInRun <= p)
         return null;
-    return [userEnd, passEnd + 1];
+    return lastAtInRun;
 }
-function collectUrlUserinfoSpans(text, json, span) {
-    const head = URL_USERINFO_PATTERN[0];
+function collectUrlCredentialSpans(text, json, span) {
+    const head = URL_CREDENTIAL_PATTERN[0];
     head.lastIndex = 0;
     for (let m = head.exec(text); m !== null; m = head.exec(text)) {
         const colon = m.index;
-        const hit = matchUserinfoAt(text, colon + 3, json);
-        if (hit === null) {
+        const start = colon + 3;
+        const at = matchUserinfoAt(text, start, json);
+        if (at === null) {
             head.lastIndex = colon + 1;
             continue;
         }
-        span(hit[0], hit[1]);
-        head.lastIndex = hit[1];
+        span(start, at);
+        head.lastIndex = at + 1;
+    }
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (c !== 63 && c !== 38 && c !== 35)
+            continue;
+        const valueStart = credentialParamValueStart(text, i + 1);
+        if (valueStart < 0)
+            continue;
+        const valueEnd = scanUrlRun(text, valueStart, "param-value", json);
+        if (valueEnd > valueStart)
+            span(valueStart, valueEnd);
+        i = valueEnd - 1;
     }
 }
 let ppkScanBytes = 0;
@@ -1437,8 +1518,8 @@ const armPool = (() => {
     const members = [];
     for (const row of STRUCTURAL_SECRET_PATTERNS) {
         const order = members.length;
-        members.push(row === URL_USERINFO_PATTERN
-            ? scannerMember(row[1], order, 2, (text, json, _observe, span) => collectUrlUserinfoSpans(text, json, span))
+        members.push(row === URL_CREDENTIAL_PATTERN
+            ? scannerMember(row[1], order, 2, (text, json, _observe, span) => collectUrlCredentialSpans(text, json, span))
             : row === SSH2_FENCE_PATTERN
                 ? scannerMember(row[1], order, 2, (text, _json, _observe, span) => collectSsh2FenceSpans(text, span))
                 : regexMember(row, ARM_RANK.structural, order, true));
@@ -1631,4 +1712,14 @@ export function redactedPreview(value, cap = 2000) {
     s = redactSecrets(s, { json: true });
     return s.length > cap ? `${s.slice(0, cap)}…[truncated]` : s;
 }
+export function buildDisplaySafeUrl(raw) {
+    if (raw === "")
+        return "";
+    if (!URL.canParse(raw))
+        return DISPLAY_SAFE_URL_TOKEN;
+    const u = new URL(raw);
+    if (!u.href.startsWith(`${u.protocol}//`))
+        return DISPLAY_SAFE_URL_TOKEN;
+    return redactSecrets(u.href);
+}
 //# sourceMappingURL=redact.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.87.3",
+  "version": "7.88.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -14,6 +14,10 @@
     "./main": {
       "default": "./dist/main.js"
     },
+    "./device-protocol": {
+      "types": "./dist/device-protocol.d.ts",
+      "default": "./dist/device-protocol.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -54,8 +58,8 @@
     "build:binary:run-local:darwin-arm64": "bun build --compile --target=bun-darwin-arm64 src/run-local.ts --outfile dist/run-local-darwin-arm64"
   },
   "dependencies": {
-    "@sema-agent/core": "7.23.2",
-    "@sema-agent/settings-schema": "2.1.0",
+    "@sema-agent/core": "7.23.3",
+    "@sema-agent/settings-schema": "3.0.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
     "mysql2": "^3.22.4",