clinkx 0.2.3 → 1.0.0

package/dist/elaris/redact.d.ts

@@ -0,0 +1,89 @@
+export interface RedactOptions {
+    apiKeyEnvName?: string | undefined;
+    apiKeyValue?: string | undefined;
+    maxDepth?: number | undefined;
+    /**
+     * Object keys whose values are exempt from BOTH the aggressive bare-entropy
+     * LONG_TOKEN_PATTERN rule AND keyword-proximity. Used to protect control-plane
+     * locators (cursors, URLs, ids, ranges, paths) from having their UUIDs/URLs/
+     * base64 cursors — or legitimate keyworded paths like
+     * `artifacts/auth_token_<hex>.log` — shredded. Preserved string values still
+     * receive the UNAMBIGUOUS credential shapes (own-key / Bearer / prefixed vendor
+     * token), and preserved object/array values are still recursed into —
+     * preservation is not a blanket redaction bypass.
+     */
+    preserveKeys?: ReadonlySet<string> | undefined;
+}
+/**
+ * Control-plane locator keys whose values must survive the aggressive
+ * bare-entropy rule so the caller still receives usable locators.
+ *
+ * LONG_TOKEN_PATTERN matches any >=32 char run of [A-Za-z0-9+/=_-], which
+ * destroys legitimate URLs/paths, UUID ids, and base64 cursors; keyword-proximity
+ * likewise over-redacts legitimate keyworded paths (e.g.
+ * `artifacts/auth_token_<hex>.log`, where the `token` keyword sits next to an
+ * opaque hex run). These keys are exempt from BOTH rules — their string values
+ * still receive the UNAMBIGUOUS credential shapes (own-key / Bearer / prefixed
+ * vendor token) and their object/array values are still recursed into, so a real
+ * credential embedded in a locator field cannot bypass redaction while legitimate
+ * locators survive.
+ */
+export declare const DEFAULT_LOCATOR_KEYS: readonly string[];
+export declare function redact(value: unknown): unknown;
+export declare function redactWithOptions(value: unknown, options?: RedactOptions): unknown;
+/**
+ * Metadata-bearing analog of {@link redact}: deep-redacts `value` in the SAME
+ * single pass and additionally reports how many redactions fired
+ * (`redaction_count`) — each [REDACTED] token substitution and each field-level
+ * clobber counts once. When `apiKeyEnvName`/`apiKeyValue` are omitted they are
+ * resolved from the environment exactly like {@link redact}, so read paths get
+ * own-credential scrubbing by default. Counting happens DURING the existing
+ * walk; the tree is never traversed twice.
+ */
+export declare function redactWithMetadata(value: unknown, options?: RedactOptions): {
+    value: unknown;
+    redaction_count: number;
+};
+/**
+ * Shared high-confidence credential detector. Returns the number of distinct
+ * high-confidence credential redactions the ruleset would apply to `text`:
+ * own-key env name/value, Bearer tokens, prefixed vendor tokens, and
+ * keyword-proximity high-entropy runs. Deliberately does NOT flag bare-entropy
+ * long tokens, git SHAs, JWTs, plain base64, or UUIDs. This is the same ruleset
+ * used by the read-path redactor — one source of truth.
+ */
+export declare function detectCredentials(text: string): {
+    count: number;
+};
+/** Convenience boolean wrapper over {@link detectCredentials}. */
+export declare function hasCredential(text: string): boolean;
+/**
+ * Deep-redact a value like {@link redact} but exempt control-plane locator keys
+ * from BOTH the aggressive bare-entropy rule AND keyword-proximity so cursors,
+ * URLs, ids, ranges, and keyworded paths (e.g. `artifacts/auth_token_<hex>.log`)
+ * survive. Preserved string values still get the UNAMBIGUOUS credential shapes
+ * (own-key / Bearer / prefixed vendor token); preserved objects/arrays still
+ * recurse. Caller-supplied `locatorKeys` EXTEND the default allowlist (they never
+ * shrink it).
+ */
+export declare function redactPreservingLocators(value: unknown, locatorKeys?: Iterable<string>): unknown;
+/**
+ * Metadata-bearing analog of {@link redactPreservingLocators}: deep-redacts
+ * `value` in the SAME single pass, exempts control-plane locators from BOTH the
+ * bare-entropy rule and keyword-proximity (they still get the unambiguous
+ * own-key / Bearer / prefixed-vendor-token scrubbing), and reports
+ * `redaction_count`. Used by the read-path client so a redaction count
+ * can bubble to the tool envelope without a second traversal.
+ */
+export declare function redactPreservingLocatorsWithMetadata(value: unknown, locatorKeys?: Iterable<string>): {
+    value: unknown;
+    redaction_count: number;
+};
+/**
+ * Scrub ONLY ClinkX's own credentials from a string: the Bearer header pattern,
+ * the api-key env-var name, and the api-key value. Deliberately does NOT apply
+ * TOKEN_LIKE_PATTERN or LONG_TOKEN_PATTERN, so raw artifact bytes (hashes,
+ * base64 blobs, long identifiers) are not corrupted. Use for explicit
+ * raw-inspection paths where the caller asked for provider bytes verbatim.
+ */
+export declare function scrubOwnCredentials(text: string): string;

package/dist/elaris/redact.js

@@ -0,0 +1,423 @@
+const DEFAULT_SECRET_FIELD_PATTERN = /(?:authorization|api[_-]?key|secret|token|password|credential|bearer)/i;
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi;
+/**
+ * High-confidence PREFIXED credential shapes. Each alternative carries a vendor
+ * marker (a scheme prefix or a fixed-length structured body) so a match is a
+ * credential, not arbitrary high-entropy content. Extends the original GitHub /
+ * Stripe / ClinkX family with AWS, Slack, Google, GitLab, npm, and Anthropic.
+ */
+const TOKEN_LIKE_PATTERN = new RegExp([
+    // prefix_<body>: stripe (sk/pk), github (ghp/gho/ghu/ghs/github_pat), npm, clinkx (cxel/cxmsg)
+    "\\b(?:sk|pk|ghp|gho|ghu|ghs|github_pat|cxel|cxmsg|npm)_[A-Za-z0-9_:-]{12,}\\b",
+    // anthropic: sk-ant-...
+    "\\bsk-ant-[A-Za-z0-9_-]{12,}\\b",
+    // gitlab personal access token: glpat-...
+    "\\bglpat-[A-Za-z0-9_-]{12,}\\b",
+    // slack: xoxb-/xoxp-/xoxa-/xoxr-/xoxs-...
+    "\\bxox[baprs]-[A-Za-z0-9-]{10,}\\b",
+    // aws access key id: AKIA/ASIA + 16 uppercase alnum
+    "\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b",
+    // google api key: AIza + 35
+    "\\bAIza[0-9A-Za-z_-]{35}\\b",
+].join("|"), "g");
+/**
+ * Aggressive bare-entropy fallback. Default OFF — it destroys legitimate content
+ * (git SHAs, JWTs, base64 blobs, UUIDs). Re-enabled only via the opt-in
+ * CLINKX_ELARIS_REDACT_AGGRESSIVE flag. See {@link isAggressiveRedaction}.
+ */
+const LONG_TOKEN_PATTERN = /\b[A-Za-z0-9+/=_-]{32,}\b/g;
+/**
+ * Credential-keyword proximity rule (single source of truth, shared by the
+ * detector and the read-path redactor). A high-entropy run is treated as a
+ * credential ONLY when one of these keywords sits within a small window of it,
+ * so secrets labelled `api_key=`, `secret:`, `password ...`, `token=`, or
+ * `authorization` are caught while bare high-entropy content is left alone.
+ */
+const CREDENTIAL_KEYWORD_PATTERN = /(?:api[_-]?key|secret|token|password|authorization)/gi;
+const HIGH_ENTROPY_RUN_PATTERN = /[A-Za-z0-9+/=_-]{16,}/g;
+const KEYWORD_PROXIMITY_WINDOW = 24;
+const DEFAULT_MAX_DEPTH = 8;
+const REDACTED = "[REDACTED]";
+/**
+ * Control-plane locator keys whose values must survive the aggressive
+ * bare-entropy rule so the caller still receives usable locators.
+ *
+ * LONG_TOKEN_PATTERN matches any >=32 char run of [A-Za-z0-9+/=_-], which
+ * destroys legitimate URLs/paths, UUID ids, and base64 cursors; keyword-proximity
+ * likewise over-redacts legitimate keyworded paths (e.g.
+ * `artifacts/auth_token_<hex>.log`, where the `token` keyword sits next to an
+ * opaque hex run). These keys are exempt from BOTH rules — their string values
+ * still receive the UNAMBIGUOUS credential shapes (own-key / Bearer / prefixed
+ * vendor token) and their object/array values are still recursed into, so a real
+ * credential embedded in a locator field cannot bypass redaction while legitimate
+ * locators survive.
+ */
+export const DEFAULT_LOCATOR_KEYS = [
+    "next_cursor",
+    "resume_cursor",
+    "cursor",
+    "status_url",
+    "result_url",
+    "content_url",
+    "events_url",
+    "logs_url",
+    "artifacts_url",
+    "session_id",
+    "chat_id",
+    "run_id",
+    "turn_id",
+    "message_id",
+    "call_id",
+    "request_id",
+    "stage_id",
+    "content_range",
+    "accept_ranges",
+    "path",
+];
+export function redact(value) {
+    const apiKeyEnvName = process.env["CLINKX_ELARIS_API_KEY_ENV"] ?? "CLINKX_ELARIS_API_KEY";
+    return redactWithOptions(value, {
+        apiKeyEnvName,
+        apiKeyValue: process.env[apiKeyEnvName],
+    });
+}
+export function redactWithOptions(value, options = {}) {
+    return redactInner(value, options, 0);
+}
+/**
+ * Metadata-bearing analog of {@link redact}: deep-redacts `value` in the SAME
+ * single pass and additionally reports how many redactions fired
+ * (`redaction_count`) — each [REDACTED] token substitution and each field-level
+ * clobber counts once. When `apiKeyEnvName`/`apiKeyValue` are omitted they are
+ * resolved from the environment exactly like {@link redact}, so read paths get
+ * own-credential scrubbing by default. Counting happens DURING the existing
+ * walk; the tree is never traversed twice.
+ */
+export function redactWithMetadata(value, options = {}) {
+    const counter = { n: 0 };
+    const redacted = redactInner(value, withEnvApiKeyDefaults(options), 0, counter);
+    return { value: redacted, redaction_count: counter.n };
+}
+function redactInner(value, options, depth, counter) {
+    if (depth > (options.maxDepth ?? DEFAULT_MAX_DEPTH))
+        return "[MaxDepth]";
+    if (typeof value === "string")
+        return redactString(value, options, counter);
+    if (value == null || typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => redactInner(item, options, depth + 1, counter));
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (options.preserveKeys?.has(key)) {
+                out[key] = redactPreservedLocator(item, options, depth, counter);
+            }
+            else if (shouldRedactField(key, options) && isRedactableFieldValue(item)) {
+                out[key] = REDACTED;
+                if (counter)
+                    counter.n += 1;
+            }
+            else {
+                out[key] = redactInner(item, options, depth + 1, counter);
+            }
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Redact a value stored under a PRESERVED locator key. Locators (cursors, URLs,
+ * ids, ranges, paths) are exactly where keyword-adjacent high-entropy runs are
+ * legitimate (e.g. `artifacts/auth_token_a1b2c3d4e5f6g7h8.log`), not secrets, so
+ * a preserved locator is EXEMPT from BOTH the bare-entropy LONG_TOKEN rule AND
+ * keyword-proximity — either would shred a legitimate path/URL/cursor. But
+ * preservation must NOT be a blanket bypass for real credentials embedded in a
+ * locator value. So:
+ *   - string  → apply ONLY the UNAMBIGUOUS credential shapes via
+ *               {@link redactUnambiguousCredentials}: own-key env name+value,
+ *               Bearer, and prefixed vendor tokens (sk, pk, ghp, sk-ant,
+ *               glpat, xox_, AKIA|ASIA, AIza). NEVER keyword-proximity and NEVER
+ *               LONG_TOKEN_PATTERN. UUIDs/URLs/base64 cursors and keyworded
+ *               paths pass through intact, while an embedded Bearer/vendor/own-key
+ *               secret is still scrubbed.
+ *   - object/array → recurse via {@link redactInner} so nested fields keep their
+ *               protection and nested preserved keys stay preserved.
+ *   - number/boolean/null → passed through unchanged.
+ */
+function redactPreservedLocator(value, options, depth, counter) {
+    if (typeof value === "string") {
+        const { text, count } = redactUnambiguousCredentials(value, options);
+        if (counter)
+            counter.n += count;
+        return text;
+    }
+    if (value !== null && typeof value === "object") {
+        return redactInner(value, options, depth + 1, counter);
+    }
+    return value;
+}
+/**
+ * Fill in env-derived own-key options (name + value) when the caller supplied
+ * neither, matching {@link redact}. A caller that passes an explicit
+ * `apiKeyEnvName` or `apiKeyValue` keeps {@link redactWithOptions} semantics
+ * (no env fallback).
+ */
+function withEnvApiKeyDefaults(options) {
+    if (options.apiKeyEnvName !== undefined || options.apiKeyValue !== undefined)
+        return options;
+    const apiKeyEnvName = process.env["CLINKX_ELARIS_API_KEY_ENV"] ?? "CLINKX_ELARIS_API_KEY";
+    return { ...options, apiKeyEnvName, apiKeyValue: process.env[apiKeyEnvName] };
+}
+function shouldRedactField(key, options) {
+    if (DEFAULT_SECRET_FIELD_PATTERN.test(key))
+        return true;
+    return options.apiKeyEnvName === key;
+}
+/**
+ * Whether a value matched by a secret-bearing FIELD NAME should be replaced with
+ * the [REDACTED] marker. Only strings (literal secrets) and objects/arrays
+ * (which may nest secrets) are clobbered. Numbers, booleans, and null are passed
+ * through: a field like `input_tokens`/`total_tokens` matches the "token"
+ * keyword but holds a count, not a credential — redacting it would corrupt
+ * legitimate typed metadata.
+ */
+function isRedactableFieldValue(value) {
+    return typeof value === "string" || (value !== null && typeof value === "object");
+}
+function redactString(value, options, counter) {
+    const { text, count } = redactHighConfidence(value, options);
+    if (counter)
+        counter.n += count;
+    if (!isAggressiveRedaction())
+        return text;
+    return text.replace(LONG_TOKEN_PATTERN, (match) => {
+        if (/^\d+$/.test(match))
+            return match;
+        if (counter)
+            counter.n += 1;
+        return REDACTED;
+    });
+}
+/**
+ * Whether the opt-in aggressive bare-entropy rule is enabled. Default OFF: read
+ * paths only redact high-confidence credential shapes so SHAs, JWTs, base64
+ * blobs, and UUIDs pass through. Set `CLINKX_ELARIS_REDACT_AGGRESSIVE=true` to
+ * restore the legacy behavior of clobbering every >=32-char alphanumeric run.
+ */
+function isAggressiveRedaction() {
+    return process.env["CLINKX_ELARIS_REDACT_AGGRESSIVE"] === "true";
+}
+/**
+ * Apply the SINGLE high-confidence credential ruleset to a string and report how
+ * many redactions fired. Shared verbatim by {@link redactString} (read-path
+ * redaction) and {@link detectCredentials} (fail-closed detection) so there is
+ * exactly one ruleset, never two that can drift. The bare-entropy
+ * LONG_TOKEN_PATTERN is deliberately NOT part of this set.
+ */
+function redactHighConfidence(value, options) {
+    const unambiguous = redactUnambiguousCredentials(value, options);
+    let text = unambiguous.text;
+    let count = unambiguous.count;
+    const proximity = redactKeywordProximity(text);
+    text = proximity.text;
+    count += proximity.count;
+    return { text, count };
+}
+/**
+ * The UNAMBIGUOUS subset of {@link redactHighConfidence}: own-key env name +
+ * own-key value (split/join), {@link BEARER_PATTERN}, and {@link
+ * TOKEN_LIKE_PATTERN} (prefixed vendor tokens). Every one of these carries an
+ * explicit vendor/scheme marker or matches ClinkX's own configured credential,
+ * so a hit is a real secret regardless of surrounding text. This subset
+ * DELIBERATELY excludes {@link redactKeywordProximity} (keyword-adjacent
+ * high-entropy runs) and the bare-entropy {@link LONG_TOKEN_PATTERN}, both of
+ * which are heuristic and over-fire on legitimate locators (paths/URLs/cursors
+ * that merely contain a credential-keyword substring next to an opaque run).
+ * Used by the preserved-locator branch so real embedded credentials are still
+ * scrubbed without shredding legitimate keyworded locators.
+ */
+function redactUnambiguousCredentials(value, options) {
+    let text = value;
+    let count = 0;
+    const bearer = replaceCounting(text, BEARER_PATTERN, () => `Bearer ${REDACTED}`);
+    text = bearer.text;
+    count += bearer.count;
+    if (options.apiKeyEnvName) {
+        const scrubbed = splitJoinCounting(text, options.apiKeyEnvName, REDACTED);
+        text = scrubbed.text;
+        count += scrubbed.count;
+    }
+    if (options.apiKeyValue) {
+        const scrubbed = splitJoinCounting(text, options.apiKeyValue, REDACTED);
+        text = scrubbed.text;
+        count += scrubbed.count;
+    }
+    const tokenLike = replaceCounting(text, TOKEN_LIKE_PATTERN, () => REDACTED);
+    text = tokenLike.text;
+    count += tokenLike.count;
+    return { text, count };
+}
+function replaceCounting(text, pattern, replacement) {
+    let count = 0;
+    const out = text.replace(pattern, (match) => {
+        count += 1;
+        return replacement(match);
+    });
+    return { text: out, count };
+}
+function splitJoinCounting(text, needle, replacement) {
+    if (!needle)
+        return { text, count: 0 };
+    const parts = text.split(needle);
+    return { text: parts.join(replacement), count: parts.length - 1 };
+}
+/**
+ * Redact each high-entropy run that sits within {@link KEYWORD_PROXIMITY_WINDOW}
+ * characters of a credential keyword. Runs with no nearby keyword (bare SHAs,
+ * UUIDs, base64) are passed through untouched.
+ *
+ * Linear (O(K+R)) equivalent of the original O(K*R) per-run keyword scan. The
+ * old "near" predicate for a run [start,end) held iff, for SOME keyword range
+ * [kStart,kEnd), one of three clauses was true: keyword-before-within-W,
+ * keyword-after-within-W, or overlap. Those three clauses union to exactly "the
+ * run intersects the keyword range expanded by W on each side" — the danger zone
+ * [kStart - W, kEnd + W] (endpoints inclusive; run end is exclusive). So we
+ * pre-expand every keyword range by W, MERGE the expanded intervals into a
+ * sorted, disjoint list of zones, then sweep the (already ascending) high-entropy
+ * runs against the (ascending) zones with one advancing index: drop zones that
+ * end before the run starts, then the run is near iff the current zone starts
+ * at/before the run end. Each sequence is visited once — a single linear pass,
+ * no per-run scan of all keywords.
+ *
+ * Worst case: K keyword ranges + R entropy runs → O(K + R) time and O(K) space
+ * for the merged zones, replacing the O(K*R) product that stalled for seconds on
+ * a ~1 MiB response densely labelled with credential keywords.
+ */
+function redactKeywordProximity(text) {
+    const keywords = findKeywordRanges(text);
+    if (keywords.length === 0)
+        return { text, count: 0 };
+    // Expand each keyword range by W on both sides and merge overlapping/touching
+    // intervals. findKeywordRanges yields ascending, non-overlapping ranges, so
+    // expanded starts stay ascending and a single linear merge suffices.
+    const W = KEYWORD_PROXIMITY_WINDOW;
+    const zones = [];
+    for (const [kStart, kEnd] of keywords) {
+        const zStart = Math.max(0, kStart - W);
+        const zEnd = kEnd + W;
+        const last = zones[zones.length - 1];
+        if (last && zStart <= last[1]) {
+            if (zEnd > last[1])
+                last[1] = zEnd;
+        }
+        else {
+            zones.push([zStart, zEnd]);
+        }
+    }
+    let count = 0;
+    let zi = 0;
+    HIGH_ENTROPY_RUN_PATTERN.lastIndex = 0;
+    const out = text.replace(HIGH_ENTROPY_RUN_PATTERN, (match, offset) => {
+        const start = offset;
+        const end = offset + match.length;
+        // Runs arrive left-to-right. Drop zones that end before this run starts;
+        // they cannot intersect this run nor any later (further-right) run.
+        while (zi < zones.length && zones[zi][1] < start)
+            zi += 1;
+        // Near iff the current (first still-relevant) zone starts at/before run end.
+        const near = zi < zones.length && zones[zi][0] <= end;
+        if (!near)
+            return match;
+        count += 1;
+        return REDACTED;
+    });
+    return { text: out, count };
+}
+function findKeywordRanges(text) {
+    const ranges = [];
+    CREDENTIAL_KEYWORD_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = CREDENTIAL_KEYWORD_PATTERN.exec(text)) !== null) {
+        ranges.push([match.index, match.index + match[0].length]);
+        if (match.index === CREDENTIAL_KEYWORD_PATTERN.lastIndex)
+            CREDENTIAL_KEYWORD_PATTERN.lastIndex += 1;
+    }
+    return ranges;
+}
+/**
+ * Shared high-confidence credential detector. Returns the number of distinct
+ * high-confidence credential redactions the ruleset would apply to `text`:
+ * own-key env name/value, Bearer tokens, prefixed vendor tokens, and
+ * keyword-proximity high-entropy runs. Deliberately does NOT flag bare-entropy
+ * long tokens, git SHAs, JWTs, plain base64, or UUIDs. This is the same ruleset
+ * used by the read-path redactor — one source of truth.
+ */
+export function detectCredentials(text) {
+    const apiKeyEnvName = process.env["CLINKX_ELARIS_API_KEY_ENV"] ?? "CLINKX_ELARIS_API_KEY";
+    const { count } = redactHighConfidence(text, {
+        apiKeyEnvName,
+        apiKeyValue: process.env[apiKeyEnvName],
+    });
+    return { count };
+}
+/** Convenience boolean wrapper over {@link detectCredentials}. */
+export function hasCredential(text) {
+    return detectCredentials(text).count > 0;
+}
+/**
+ * Deep-redact a value like {@link redact} but exempt control-plane locator keys
+ * from BOTH the aggressive bare-entropy rule AND keyword-proximity so cursors,
+ * URLs, ids, ranges, and keyworded paths (e.g. `artifacts/auth_token_<hex>.log`)
+ * survive. Preserved string values still get the UNAMBIGUOUS credential shapes
+ * (own-key / Bearer / prefixed vendor token); preserved objects/arrays still
+ * recurse. Caller-supplied `locatorKeys` EXTEND the default allowlist (they never
+ * shrink it).
+ */
+export function redactPreservingLocators(value, locatorKeys) {
+    return redactWithOptions(value, locatorPreservingOptions(locatorKeys));
+}
+/**
+ * Metadata-bearing analog of {@link redactPreservingLocators}: deep-redacts
+ * `value` in the SAME single pass, exempts control-plane locators from BOTH the
+ * bare-entropy rule and keyword-proximity (they still get the unambiguous
+ * own-key / Bearer / prefixed-vendor-token scrubbing), and reports
+ * `redaction_count`. Used by the read-path client so a redaction count
+ * can bubble to the tool envelope without a second traversal.
+ */
+export function redactPreservingLocatorsWithMetadata(value, locatorKeys) {
+    const counter = { n: 0 };
+    const redacted = redactInner(value, locatorPreservingOptions(locatorKeys), 0, counter);
+    return { value: redacted, redaction_count: counter.n };
+}
+function locatorPreservingOptions(locatorKeys) {
+    const apiKeyEnvName = process.env["CLINKX_ELARIS_API_KEY_ENV"] ?? "CLINKX_ELARIS_API_KEY";
+    const preserveKeys = new Set(DEFAULT_LOCATOR_KEYS);
+    if (locatorKeys) {
+        for (const key of locatorKeys)
+            preserveKeys.add(key);
+    }
+    return {
+        apiKeyEnvName,
+        apiKeyValue: process.env[apiKeyEnvName],
+        preserveKeys,
+    };
+}
+/**
+ * Scrub ONLY ClinkX's own credentials from a string: the Bearer header pattern,
+ * the api-key env-var name, and the api-key value. Deliberately does NOT apply
+ * TOKEN_LIKE_PATTERN or LONG_TOKEN_PATTERN, so raw artifact bytes (hashes,
+ * base64 blobs, long identifiers) are not corrupted. Use for explicit
+ * raw-inspection paths where the caller asked for provider bytes verbatim.
+ */
+export function scrubOwnCredentials(text) {
+    const apiKeyEnvName = process.env["CLINKX_ELARIS_API_KEY_ENV"] ?? "CLINKX_ELARIS_API_KEY";
+    const apiKeyValue = process.env[apiKeyEnvName];
+    let scrubbed = text.replace(BEARER_PATTERN, `Bearer ${REDACTED}`);
+    scrubbed = scrubbed.split(apiKeyEnvName).join(REDACTED);
+    if (apiKeyValue) {
+        scrubbed = scrubbed.split(apiKeyValue).join(REDACTED);
+    }
+    return scrubbed;
+}
+//# sourceMappingURL=redact.js.map

package/dist/elaris/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.js","sourceRoot":"","sources":["../../src/elaris/redact.ts"],"names":[],"mappings":"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"}

package/dist/elaris/run-id.d.ts

@@ -0,0 +1,5 @@
+export declare const ELARIS_RUN_ID_PATTERN: RegExp;
+export declare const ELARIS_RUN_ID_PREFIX = "cxel_";
+export declare function isValidElarisRunId(runId: string): boolean;
+export declare function assertValidElarisRunId(runId: string): string;
+export declare function generateElarisRunId(now?: Date): string;

package/dist/elaris/run-id.js

@@ -0,0 +1,20 @@
+import { randomBytes } from "node:crypto";
+import { InvalidParamsError } from "../errors.js";
+export const ELARIS_RUN_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+export const ELARIS_RUN_ID_PREFIX = "cxel_";
+export function isValidElarisRunId(runId) {
+    return ELARIS_RUN_ID_PATTERN.test(runId);
+}
+export function assertValidElarisRunId(runId) {
+    if (!isValidElarisRunId(runId)) {
+        throw new InvalidParamsError("run_id must match ^[A-Za-z0-9_-]{1,64}$.");
+    }
+    return runId;
+}
+export function generateElarisRunId(now = new Date()) {
+    const timestamp = now.toISOString().replace(/\D/g, "").slice(0, 14);
+    const suffix = randomBytes(9).toString("base64url");
+    const runId = `${ELARIS_RUN_ID_PREFIX}${timestamp}_${suffix}`;
+    return assertValidElarisRunId(runId);
+}
+//# sourceMappingURL=run-id.js.map

package/dist/elaris/run-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-id.js","sourceRoot":"","sources":["../../src/elaris/run-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,CAAC,MAAM,qBAAqB,GAAG,uBAAuB,CAAC;AAC7D,MAAM,CAAC,MAAM,oBAAoB,GAAG,OAAO,CAAC;AAE5C,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAO,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,KAAa;IAClD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,kBAAkB,CAAC,0CAA0C,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAY,IAAI,IAAI,EAAE;IACxD,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACpE,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IACpD,MAAM,KAAK,GAAG,GAAG,oBAAoB,GAAG,SAAS,IAAI,MAAM,EAAE,CAAC;IAC9D,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC;AACvC,CAAC"}

package/dist/elaris/status.d.ts

@@ -0,0 +1,45 @@
+import type { AgentSessionErrorSummary, AgentSessionStage, AgentSessionStatusResponse, AgentSessionURLResponse, ElarisRawStatus } from "./types.js";
+export type ElarisNormalizedStatus = "running" | "succeeded" | "failed" | "cancelling" | "cancelled" | "orphaned";
+export interface ElarisStatusSnapshot {
+    run_id: string;
+    raw_status: ElarisRawStatus;
+    normalized_status: ElarisNormalizedStatus;
+    terminal: boolean;
+    source: "create" | "status" | "synthetic";
+    session_id?: string | undefined;
+    chat_id?: string | undefined;
+    status_url?: string | undefined;
+    result_url?: string | undefined;
+    events_url?: string | undefined;
+    logs_url?: string | undefined;
+    artifacts_url?: string | undefined;
+    cleaned_up_at?: string | null | undefined;
+    artifacts_available?: boolean | undefined;
+    status_reason?: string | null | undefined;
+    started_at?: string | null | undefined;
+    completed_at?: string | null | undefined;
+    cleanup_due_at?: string | null | undefined;
+    cleanup_grace_remaining_ms?: number | null | undefined;
+    progress?: number | null | undefined;
+    result_available?: boolean | undefined;
+    result_bytes?: number | null | undefined;
+    stages?: AgentSessionStage[] | undefined;
+    error?: AgentSessionErrorSummary | null | undefined;
+    failure_class?: string | null | undefined;
+    keep_alive?: boolean | undefined;
+    keep_alive_known?: boolean | undefined;
+}
+export declare function normalizeElarisStatus(status: ElarisRawStatus): ElarisNormalizedStatus;
+export declare function isTerminalElarisStatus(status: ElarisRawStatus): boolean;
+export declare function mapCreateResponseToSnapshot(response: AgentSessionURLResponse): ElarisStatusSnapshot;
+export declare function mapStatusResponseToSnapshot(response: AgentSessionStatusResponse): ElarisStatusSnapshot;
+/**
+ * Single source of truth for whether a RAW Elaris status is an error
+ * disposition. Shared by {@link snapshotIsError} (full snapshots) and callers
+ * that only hold a raw status not yet folded into a snapshot (message-derived
+ * bodies), so the two can never drift.
+ */
+export declare function rawStatusIsError(status: ElarisRawStatus): boolean;
+export declare function snapshotIsError(snapshot: ElarisStatusSnapshot): boolean;
+export declare function withKnownKeepAlive(snapshot: ElarisStatusSnapshot, keepAlive: boolean): ElarisStatusSnapshot;
+export declare function mergeCreateProvenance(snapshot: ElarisStatusSnapshot, createSnapshot: ElarisStatusSnapshot): ElarisStatusSnapshot;