@skrr-ai/cli 0.1.104 → 0.1.106

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/telemetryRedaction.js

@@ -16,10 +16,30 @@
  * and `api/server/services/HostedPreview/__tests__/telemetryRedaction.spec.js` against tokens the issuer really
  * mints, so a change to either side fails there rather than in a trace nobody reads.
  *
+ * THE OTHER PATH CREDENTIALS (OSK-16174). Four more bearer credentials travel in a URL, and until they were added here
+ * only the request logger's path rewrite (`requestLogger.js`) knew them, so the same address that was scrubbed from a
+ * log line reached a trace and an error report in full: a workspace invitation (`wsi_`), a platform invitation
+ * (`pinv_`), a member's invitation link (`usr_`) and an operator's (`adm2_`, and the older `adm_`). Unlike `pvw_`, whose
+ * prefix is rare enough to match on its own, `usr_` and `adm_` begin ordinary words and identifiers (`/usr_local`,
+ * `adm_users`), so each of these is recognised by the SHAPE its minting code gives it, and a lookalike is left alone:
+ *
+ *   wsi_ / pinv_ / usr_ / adm2_   `<prefix>_<32 hex>.<version>.<key id>.<43 base64url>`, from `buildCredential` in
+ *                                 `api/models/WorkspaceInvite.js` and `PlatformInvitation.js` and `buildUserCode` and
+ *                                 `buildAdminCode` in `InvitationCode.js`. The older member link, `usr_<32 hex>.<24
+ *                                 base64url>`, has the same first two fields. Matched from the prefix to the end of the
+ *                                 token's characters once the 32-hex id and its dot are there, so a credential cut off
+ *                                 later in the log line is still redacted whole.
+ *   adm_                          `adm_<43 base64url>`, the older operator code (`generateCode`: 32 random bytes).
+ *                                 Exactly 43 characters, because that is the only length it has.
+ *
+ * `api/server/services/HostedPreview/__tests__/telemetryRedaction.spec.js` mints credentials with the real minting
+ * code and requires every one to come out as the marker, so a change to either side fails there.
+ *
  * WHAT IT DOES NOT. A prefix that is itself percent-encoded (`%70vw_`) is not recognised: nothing in this
- * repository writes one, and a scan that decoded every string first would cost every sink on every record. The
- * request log's own `/[credential]` rewrite (`requestLogger.js`) covers the other credential prefixes and
- * stays as it is.
+ * repository writes one, and a scan that decoded every string first would cost every sink on every record. A
+ * credential cut off before its id is whole (`pinv_0123abc`) is an identifier, not yet the secret, and is left as it
+ * is. The request log's own `/[credential]` rewrite stays as it is, and is looser (any `wsi_`, `pinv_`, `usr_`,
+ * `adm_`, `adm2_` or `pvw_` path segment), because a path segment is a place a credential is known to be.
  *
  * COST. Linear in the input. The only nested repetition is `%(?:25)*XX`, and `XX` is never `25`, so the engine
  * cannot read one run of `25`s two ways; the tests feed it a megabyte of the worst shapes.
@@ -43,11 +63,36 @@ const TOKEN_CHAR = '(?:[A-Za-z0-9._-]|%(?:25)*(?:2[DdEe]|3[0-9]|4[1-9A-Fa-f]|5[0
  * nothing and redacting twice changes nothing.
  */
 const PREVIEW_TOKEN = new RegExp(`pvw(?:_|%(?:25)*5[Ff])${TOKEN_CHAR}+`, 'g');
+/**
+ * A prefix's underscore, which (like the token's own characters) may be written as a percent-escape, once or several
+ * times; and the dot that ends an id.
+ */
+const UNDERSCORE = '(?:_|%(?:25)*5[Ff])';
+const DOT = '(?:\\.|%(?:25)*2[Ee])';
+/**
+ * `wsi`, `pinv`, `usr` or `adm2`, an underscore, and then a lookahead that insists on what the minting code writes
+ * next: 32 lowercase hex characters and the dot that ends them. Everything the credential is made of follows, and the
+ * prefix is captured so the marker can say which kind it was. `usr_<40 hex>`, `usr_00000001` and `/usr_profile` have no
+ * dot after exactly 32 hex characters, so they match nothing.
+ */
+const SIGNED_CREDENTIAL = new RegExp(`(wsi|pinv|usr|adm2)${UNDERSCORE}(?=[0-9a-f]{32}${DOT})${TOKEN_CHAR}+`, 'g');
+/**
+ * The older operator code: `adm_` and exactly 43 base64url characters (32 random bytes), not followed by another one.
+ * A shorter or longer run of letters is a name, not this credential. The characters are the plain alphabet and not
+ * `TOKEN_CHAR`, whose dot would swallow the full stop at the end of a sentence.
+ */
+const LEGACY_OPERATOR_CODE = new RegExp(`(adm)${UNDERSCORE}(?=[A-Za-z0-9_-]{43}(?![A-Za-z0-9_-]))[A-Za-z0-9_-]{43}`, 'g');
+/** Cheap test before any of the expressions: a string with none of these cannot hold a credential. */
+const CREDENTIAL_HINTS = ['pvw', 'wsi', 'pinv', 'usr', 'adm'];
+const credentialMarker = (_match, prefix) => `${prefix}_[redacted]`;
 export function redactPreviewTokens(value) {
-    if (typeof value !== 'string' || value.indexOf('pvw') === -1) {
+    if (typeof value !== 'string' || !CREDENTIAL_HINTS.some((hint) => value.indexOf(hint) !== -1)) {
         return value;
     }
-    return value.replace(PREVIEW_TOKEN, PREVIEW_TOKEN_REDACTION);
+    return value
+        .replace(PREVIEW_TOKEN, PREVIEW_TOKEN_REDACTION)
+        .replace(SIGNED_CREDENTIAL, credentialMarker)
+        .replace(LEGACY_OPERATOR_CODE, credentialMarker);
 }
 const DEFAULT_MAX_NODES = 50_000;
 const DEFAULT_MAX_DEPTH = 32;

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.4.23",
+  "version": "0.4.25",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {