codiedev 0.9.89 → 0.9.91

package/dist/scrub/promptRules.d.ts

@@ -0,0 +1,119 @@
+export interface Redaction {
+    rule: string;
+    start: number;
+    end: number;
+}
+export interface ScrubResult {
+    text: string;
+    redactions: Redaction[];
+}
+/** Rules a caller adds for one scrub (a company's own token formats). */
+export interface ExtraRule {
+    name: string;
+    re: RegExp;
+    keywords?: readonly string[];
+}
+/** Shannon entropy in bits per character, as Gitleaks measures it. */
+export declare function shannonEntropy(s: string): number;
+export declare function scrubSecrets(input: string, opts?: {
+    extraRules?: readonly ExtraRule[];
+}): ScrubResult;
+/** Rewrite `input` with each span replaced by `[REDACTED:<rule>]`. Spans must
+ *  be sorted by start and not overlap. One forward pass: repeated
+ *  slice+concat would copy the whole string per redaction (quadratic). */
+export declare function redactSpans(input: string, spans: readonly Redaction[]): string;
+/** Where in a session a secret appeared. "typed" is a short message the
+ *  person wrote; "pasted" is a long one (a log, config or JSON dump pasted in);
+ *  "attached" is text the harness added to the person's turn (an @-mentioned
+ *  file, a resumed session's summary). Older rows say "prompt" for all three. */
+export type SecretWhere = "typed" | "pasted" | "attached" | "prompt" | "tool_call" | "commit" | "tool_output" | "assistant" | "unknown";
+export interface SecretLocation {
+    where: SecretWhere;
+    /** Tool or MCP tool name for tool calls/outputs when the transcript has it. */
+    tool?: string;
+}
+export interface SecretFinding {
+    rule: string;
+    /** Last four alphanumeric characters of the redacted value — enough for a
+     *  person to recognise which key to rotate, never enough to use it. */
+    hint: string;
+    /** Distinct places in the session the key appeared. */
+    locations: SecretLocation[];
+    /** The variable or field it was assigned to (`X_BEARER_TOKEN`), when the
+     *  text shows one. A name, never the value. */
+    name?: string;
+    /** The file it was written to or read from (`altcap-bot/.env`), when the
+     *  text shows one: last two path parts only. */
+    file?: string;
+}
+/** What a caller may check before a key becomes a finding (exceptions).
+ *  `value` is the key itself: use it to compare, never store it. */
+export interface KeyContext {
+    rule: string;
+    value: string;
+    name?: string;
+    file?: string;
+}
+export declare const GENERIC_RULES: ReadonlySet<string>;
+/** Values that share a key's shape but are test or sample values: words
+ *  joined by _ or - with only digits or one repeated character between
+ *  (`cdv_local_pilot_token_2026`, `…_token_000000`), a long counting run
+ *  (`sk-1234567890…`), or a long repeated tail. Still removed from sessions;
+ *  just not listed as a key to rotate. */
+export declare function looksLikeTestValue(value: string): boolean;
+export declare const isTestFile: (file: string) => boolean;
+/** Where in one transcript line (a JSONL record) some text appeared, and the
+ *  file that line reads or writes, if it names one. For any detector that
+ *  works line by line (PHI/PII). `text` is the matched text as it reads
+ *  after JSON unescaping. */
+export declare function locateInLine(line: string, text: string): SecretLocation & {
+    file?: string;
+};
+/** Where each `[REDACTED:<rule>]` marker sits in an already-scrubbed
+ *  transcript. Re-labels older findings that predate typed/pasted/attached. */
+export declare function locateMarkers(scrubbed: string, rule: string): SecretLocation[];
+/** Rules that match a shape (a secret-named variable, a header, a URL, a PEM
+ *  block) rather than a provider's own key format. */
+export declare const SHAPE_RULES: ReadonlySet<string>;
+/** The name or location of a secret, or a value built from words, rather
+ *  than a random key: an ARN, a secret-store path, or a value whose letters
+ *  are mostly whole words (`mobile-data/client2`, `bracecomb-hc-service`,
+ *  `mobileDataClientV2`). A random key does not break into words, whatever
+ *  separators it has: under 1% of random 16-character keys pass this, and
+ *  next to none at 24 or more. */
+export declare function namesASecret(v: string): boolean;
+/** True when a redacted value should not be listed as a key to rotate: a
+ *  placeholder, a sample or test value, a reference to a variable, or a
+ *  credential that expires by itself. `now` is injectable for tests. */
+export declare function notWorthRotating(k: KeyContext, now?: number): boolean;
+/** Last four letters or digits of a value. A PEM block ends in a fixed
+ *  footer, and in a transcript its line breaks are a literal `\n`: the hint
+ *  comes from the key body, without either. */
+export declare function hintOf(rule: string, value: string): string;
+/** One finding per distinct (rule, last-4) in a scrub result, with every
+ *  distinct place it appeared. */
+export declare function secretFindings(input: string, redactions: Redaction[], opts?: {
+    skip?: (k: KeyContext) => boolean;
+    now?: number;
+}): SecretFinding[];
+export interface PossibleSecret {
+    label: string;
+    prefix?: string;
+    hint: string;
+    length: number;
+    shape: "hex" | "base64" | "alnum";
+    snippet: string;
+    locations: SecretLocation[];
+    /** Spans in the text this was read from, for redaction once confirmed. */
+    spans: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+export declare function possibleSecrets(text: string, limit?: number): PossibleSecret[];
+/** Redact every occurrence of an already-reviewed possible secret. */
+export declare function redactPossible(text: string, match: {
+    label: string;
+    hint: string;
+    length: number;
+}, rule?: string): ScrubResult;