@lapismd/agent-redaction 0.0.0-stage → 0.1.0

package/dist/secrets.d.ts

@@ -0,0 +1,13 @@
+import { type Span } from "./types.js";
+export declare class SecretRegistry {
+    #private;
+    get valid(): boolean;
+    add(values: readonly string[]): boolean;
+    spans(text: string): Span[];
+    clear(): void;
+    dispose(): void;
+}
+export declare function maskSpans(text: string, spans: readonly Span[]): string;
+export declare function formatSpans(text: string): Span[];
+export declare function sensitiveKey(key: string): boolean;
+export declare function stripTerminalControls(text: string): string;

package/dist/secrets.js

@@ -0,0 +1,126 @@
+import { EXTERNAL, LIMITS, REDACTED, utf8Size, validUnicode, } from "./types.js";
+const markers = [REDACTED, EXTERNAL, "$WORKSPACE[", "$HOME", "$TMP"];
+export class SecretRegistry {
+    #values = new Set();
+    #variants = [];
+    #valid = true;
+    get valid() {
+        return this.#valid;
+    }
+    add(values) {
+        if (!this.#valid)
+            return false;
+        try {
+            const next = new Set(this.#values);
+            for (const value of values) {
+                if (typeof value !== "string" ||
+                    !value ||
+                    !validUnicode(value) ||
+                    markers.some((m) => m.includes(value) || value.includes(m)))
+                    throw 0;
+                next.add(value);
+                if (next.size > LIMITS.secrets)
+                    throw 0;
+            }
+            if ([...next].reduce((n, value) => n + utf8Size(value), 0) >
+                LIMITS.secretBytes)
+                throw 0;
+            const variants = new Set();
+            for (const value of next) {
+                const bytes = new TextEncoder().encode(value);
+                let binary = "";
+                for (const byte of bytes)
+                    binary += String.fromCharCode(byte);
+                const encoded = btoa(binary);
+                for (const candidate of [
+                    value,
+                    encodeURIComponent(value),
+                    JSON.stringify(value).slice(1, -1),
+                    encoded,
+                    encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""),
+                ])
+                    variants.add(candidate);
+            }
+            this.#values = next;
+            this.#variants = [...variants].sort((a, b) => b.length - a.length);
+            return true;
+        }
+        catch {
+            this.clear();
+            this.#valid = false;
+            return false;
+        }
+    }
+    spans(text) {
+        const spans = [];
+        const uriNormalized = text.replace(/%[a-f0-9]{2}/gi, (match) => match.toUpperCase());
+        for (const value of this.#variants) {
+            const source = /%[A-F0-9]{2}/.test(value) ? uriNormalized : text;
+            let start = source.indexOf(value);
+            while (start !== -1) {
+                spans.push({ start, end: start + value.length });
+                if (spans.length > LIMITS.text)
+                    throw 0;
+                start = source.indexOf(value, start + 1);
+            }
+        }
+        return spans;
+    }
+    clear() {
+        this.#values.clear();
+        this.#variants = [];
+    }
+    dispose() {
+        this.clear();
+        this.#valid = false;
+    }
+}
+export function maskSpans(text, spans) {
+    const sorted = [...spans].sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const span of sorted) {
+        if (!Number.isInteger(span.start) ||
+            !Number.isInteger(span.end) ||
+            span.start < 0 ||
+            span.end > text.length ||
+            span.end <= span.start)
+            throw 0;
+        const previous = merged.at(-1);
+        if (previous && span.start < previous.end)
+            previous.end = Math.max(previous.end, span.end);
+        else
+            merged.push({ ...span });
+    }
+    let cursor = 0, output = "";
+    for (const span of merged) {
+        output += text.slice(cursor, span.start) + REDACTED;
+        cursor = span.end;
+    }
+    return output + text.slice(cursor);
+}
+// These are context rules, not entropy detection. Public identifiers remain intact.
+const patterns = [
+    /-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----[\s\S]*?(?:-----END (?:[A-Z0-9 ]+ )?PRIVATE KEY-----|$)/g,
+    /\bnsec1[023456789acdefghjklmnpqrstuvwxyz]{20,}\b/gi,
+    /\b(?:Bearer|Basic)\s+[^\s"'<>]+/gi,
+    /\b(?:password|passwd|secret|token|api[_-]?key|private[_-]?key|authorization|cookie)\s*[=:]\s*(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;]+)/gi,
+    /\b(?:bunker|nostrconnect):\/\/[^\s<>"']+/gi,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^\s/@:]+:[^\s/@]+@/gi,
+    /[?&](?:access_token|refresh_token|api_key|token|secret|password)=[^&#\s"']+/gi,
+];
+export function formatSpans(text) {
+    return patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({
+        start: match.index,
+        end: match.index + match[0].length,
+    })));
+}
+export function sensitiveKey(key) {
+    return (/(?:^|[_\-.])(?:password|passwd|secret|secrets|token|credentials?|authorization|cookie|cookies|env|environment|privatekey|apikey|accesskey|signingkey)(?:$|[_\-.])/i.test(key.replace(/([a-z])([A-Z])/g, "$1_$2")) ||
+        /^(?:api|private|access|refresh|signing)[_\-.]?(?:key|token)$/i.test(key));
+}
+export function stripTerminalControls(text) {
+    return text
+        .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\|$)/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, "");
+}

package/dist/stdio.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { type Json, type Result } from "./types.js";
+export declare function sanitizeStdioRequest(input: unknown): Promise<Result<Json>>;

package/dist/stdio.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { createNodeRedaction } from "./node.js";
+import { omit, } from "./types.js";
+const MAX_INPUT_BYTES = 6 * 1024 * 1024;
+function record(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+function roots(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        return null;
+    const result = [];
+    for (const item of value) {
+        if (!record(item))
+            return null;
+        const allowed = new Set([
+            "kind",
+            "path",
+            "id",
+            "repositoryId",
+            "aliases",
+            "caseSensitive",
+        ]);
+        if (Object.keys(item).some((key) => !allowed.has(key)))
+            return null;
+        if (!["workspace", "home", "temp"].includes(String(item.kind)) ||
+            typeof item.path !== "string" ||
+            (item.id !== undefined && typeof item.id !== "string") ||
+            (item.repositoryId !== undefined &&
+                typeof item.repositoryId !== "string") ||
+            (item.caseSensitive !== undefined &&
+                typeof item.caseSensitive !== "boolean") ||
+            (item.aliases !== undefined &&
+                (!Array.isArray(item.aliases) ||
+                    item.aliases.some((alias) => typeof alias !== "string"))))
+            return null;
+        result.push(item);
+    }
+    return result;
+}
+function policy(value) {
+    if (value === undefined)
+        return {};
+    if (!record(value))
+        return undefined;
+    if (Object.keys(value).some((key) => !["secrets", "roots", "destination"].includes(key)))
+        return undefined;
+    const trusted = roots(value.roots);
+    if (trusted === null)
+        return undefined;
+    if (value.secrets !== undefined &&
+        (!Array.isArray(value.secrets) ||
+            value.secrets.some((secret) => typeof secret !== "string")))
+        return undefined;
+    if (value.destination !== undefined &&
+        value.destination !== "public" &&
+        value.destination !== "private-portable")
+        return undefined;
+    return {
+        ...(value.secrets ? { secrets: value.secrets } : {}),
+        ...(trusted ? { roots: trusted } : {}),
+        ...(value.destination ? { destination: value.destination } : {}),
+    };
+}
+export async function sanitizeStdioRequest(input) {
+    if (!record(input) || input.version !== 1 || !("value" in input))
+        return omit("invalid_input");
+    if (Object.keys(input).some((key) => !["version", "value", "policy"].includes(key)))
+        return omit("invalid_input");
+    const selected = policy(input.policy);
+    if (!selected)
+        return omit("policy_invalid");
+    let runtime;
+    try {
+        runtime = createNodeRedaction(selected);
+        return await runtime.scope.value(input.value);
+    }
+    catch {
+        return omit("invalid_input");
+    }
+    finally {
+        runtime?.dispose();
+    }
+}
+async function readInput() {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const next = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += next.byteLength;
+        if (bytes > MAX_INPUT_BYTES) {
+            chunks.length = 0;
+            continue;
+        }
+        chunks.push(next);
+    }
+    if (bytes > MAX_INPUT_BYTES)
+        return { ok: false, result: omit("limit_exceeded") };
+    try {
+        return {
+            ok: true,
+            value: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks))),
+        };
+    }
+    catch {
+        return { ok: false, result: omit("invalid_input") };
+    }
+}
+async function main() {
+    const input = await readInput();
+    const result = input.ok
+        ? await sanitizeStdioRequest(input.value)
+        : input.result;
+    process.stdout.write(JSON.stringify(result));
+}
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void main().catch(() => {
+        process.stdout.write(JSON.stringify(omit("invalid_input")));
+    });
+}

package/dist/stream.d.ts

@@ -0,0 +1,10 @@
+import { RedactionScope } from "./sanitizer.js";
+import { type Result, type Omission, type OmissionReason } from "./types.js";
+export declare class CompleteBlock {
+    #private;
+    private readonly scope;
+    constructor(scope: RedactionScope);
+    append(chunk: string | Uint8Array): void;
+    cancel(reason?: OmissionReason): Omission;
+    finish(): Promise<Result<string>>;
+}

package/dist/stream.js

@@ -0,0 +1,62 @@
+import { LIMITS, omit, utf8Size, } from "./types.js";
+export class CompleteBlock {
+    scope;
+    #decoder = new TextDecoder("utf-8", { fatal: true });
+    #parts = [];
+    #bytes = 0;
+    #result;
+    #pending;
+    #mode;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    append(chunk) {
+        if (this.#result || this.#pending)
+            return;
+        try {
+            const mode = typeof chunk === "string" ? "text" : "bytes";
+            if (this.#mode && this.#mode !== mode) {
+                this.cancel("invalid_input");
+                return;
+            }
+            this.#mode = mode;
+            this.#bytes +=
+                typeof chunk === "string" ? utf8Size(chunk) : chunk.byteLength;
+            if (this.#bytes > LIMITS.text || this.#parts.length >= 65536) {
+                this.cancel("limit_exceeded");
+                return;
+            }
+            this.#parts.push(typeof chunk === "string"
+                ? chunk
+                : this.#decoder.decode(chunk, { stream: true }));
+        }
+        catch {
+            this.cancel("invalid_input");
+        }
+    }
+    cancel(reason = "cancelled") {
+        this.#parts = [];
+        this.#decoder = new TextDecoder("utf-8", { fatal: true });
+        const result = omit(reason);
+        if (!this.#result)
+            this.#result = result;
+        return this.#result.status === "omitted" ? this.#result : result;
+    }
+    async finish() {
+        if (this.#result)
+            return this.#result;
+        if (this.#pending)
+            return this.#pending;
+        try {
+            const text = this.#parts.join("") + this.#decoder.decode();
+            this.#parts = [];
+            this.#pending = this.scope
+                .text(text)
+                .then((result) => (this.#result ??= result));
+            return await this.#pending;
+        }
+        catch {
+            return this.cancel("invalid_input");
+        }
+    }
+}

package/dist/sync-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sync-worker.js

@@ -0,0 +1,36 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { RedactionScope } from "./sanitizer.js";
+import { secretlintDetector } from "./secretlint.js";
+import { omit } from "./types.js";
+const scope = new RedactionScope({
+    ...workerData.policy,
+    detector: secretlintDetector,
+});
+parentPort.on("message", async ({ operation, input, buffer, }) => {
+    const state = new Int32Array(buffer, 0, 2);
+    const bytes = new Uint8Array(buffer, 8);
+    try {
+        const result = operation === "register"
+            ? scope.registerSecrets(input)
+            : operation === "text"
+                ? await scope.text(input)
+                : operation === "path"
+                    ? await scope.path(input)
+                    : await scope.value(input);
+        const encoded = new TextEncoder().encode(JSON.stringify(result));
+        if (encoded.byteLength > bytes.length)
+            throw 0;
+        bytes.set(encoded);
+        Atomics.store(state, 1, encoded.byteLength);
+        Atomics.store(state, 0, 1);
+    }
+    catch {
+        const encoded = new TextEncoder().encode(JSON.stringify(omit("detector_failure")));
+        bytes.set(encoded);
+        Atomics.store(state, 1, encoded.byteLength);
+        Atomics.store(state, 0, 1);
+    }
+    finally {
+        Atomics.notify(state, 0);
+    }
+});

package/dist/sync.d.ts

@@ -0,0 +1,14 @@
+import { type Json, type Policy, type Result, type LogicalPath } from "./types.js";
+/** For synchronous database adapters; ordinary capture should use async scopes. */
+export declare class SynchronousRedaction {
+    #private;
+    private readonly policy;
+    private readonly timeoutMs;
+    constructor(policy?: Omit<Policy, "detector">, timeoutMs?: number);
+    get policyId(): string;
+    text(value: string): Result<string>;
+    value(value: unknown): Result<Json>;
+    path(value: string): Result<LogicalPath>;
+    registerSecrets(values: readonly string[]): boolean;
+    dispose(): void;
+}

package/dist/sync.js

@@ -0,0 +1,142 @@
+import { Worker } from "node:worker_threads";
+import { LIMITS, omit, utf8Size, } from "./types.js";
+/** Clone only plain DTO data before structured-clone could invoke accessors. */
+function snapshot(input) {
+    let bytes = 0, nodes = 0;
+    const seen = new Set();
+    const visit = (value, depth) => {
+        if (++nodes > 100_000 || depth > LIMITS.depth)
+            throw 0;
+        if (typeof value === "string") {
+            bytes += utf8Size(value);
+            if (bytes > LIMITS.record)
+                throw 0;
+            return value;
+        }
+        if (value === null ||
+            typeof value === "boolean" ||
+            (typeof value === "number" && Number.isFinite(value)))
+            return value;
+        if (typeof value !== "object" ||
+            seen.has(value) ||
+            Object.getOwnPropertySymbols(value).length)
+            throw 0;
+        const array = Array.isArray(value), prototype = Object.getPrototypeOf(value);
+        if (array
+            ? prototype !== Array.prototype
+            : prototype !== Object.prototype && prototype !== null)
+            throw 0;
+        seen.add(value);
+        const result = Object.create(null), items = [];
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+            if (array && key === "length")
+                continue;
+            bytes += utf8Size(key) + 8;
+            if (bytes > LIMITS.record ||
+                !descriptor.enumerable ||
+                !("value" in descriptor) ||
+                ["toJSON", "__proto__", "constructor", "prototype"].includes(key))
+                throw 0;
+            if (array && key !== String(items.length))
+                throw 0;
+            const next = visit(descriptor.value, depth + 1);
+            if (array)
+                items.push(next);
+            else
+                result[key] = next;
+        }
+        if (array && items.length !== value.length)
+            throw 0;
+        seen.delete(value);
+        return array ? items : result;
+    };
+    return visit(input, 0);
+}
+function freeze(value) {
+    if (value && typeof value === "object") {
+        for (const item of Object.values(value))
+            freeze(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+/** For synchronous database adapters; ordinary capture should use async scopes. */
+export class SynchronousRedaction {
+    policy;
+    timeoutMs;
+    #worker;
+    #closed = false;
+    #buffer = new SharedArrayBuffer(LIMITS.record + 4104);
+    constructor(policy = {}, timeoutMs = 10_000) {
+        this.policy = policy;
+        this.timeoutMs = timeoutMs;
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000)
+            throw new Error("policy_invalid");
+    }
+    get policyId() {
+        return `agent-redaction/1/${this.policy.destination ?? "public"}/secretlint-13.0.5-explicit-27-v1`;
+    }
+    #call(operation, input) {
+        if (this.#closed)
+            return omit("policy_invalid");
+        let safeInput;
+        try {
+            safeInput = snapshot(input);
+        }
+        catch {
+            return omit("invalid_input");
+        }
+        try {
+            if (!this.#worker) {
+                this.#worker = new Worker(new URL("./sync-worker.js", import.meta.url), {
+                    workerData: { policy: this.policy },
+                    env: {},
+                    stdout: true,
+                    stderr: true,
+                    resourceLimits: { maxOldGenerationSizeMb: 128 },
+                });
+                this.#worker.stdout?.resume();
+                this.#worker.stderr?.resume();
+                this.#worker.on("error", () => this.dispose());
+                this.#worker.unref();
+            }
+            const buffer = this.#buffer;
+            const state = new Int32Array(buffer, 0, 2);
+            Atomics.store(state, 0, 0);
+            Atomics.store(state, 1, 0);
+            this.#worker.postMessage({ operation, input: safeInput, buffer });
+            if (Atomics.wait(state, 0, 0, this.timeoutMs) === "timed-out" ||
+                Atomics.load(state, 0) !== 1) {
+                this.dispose();
+                return omit("detector_failure");
+            }
+            return freeze(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(buffer, 8, Atomics.load(state, 1)))));
+        }
+        catch {
+            this.dispose();
+            return omit("detector_failure");
+        }
+    }
+    text(value) {
+        return this.#call("text", value);
+    }
+    value(value) {
+        return this.#call("value", value);
+    }
+    path(value) {
+        return this.#call("path", value);
+    }
+    registerSecrets(values) {
+        const result = this.#call("register", values);
+        if (result !== true) {
+            this.dispose();
+            return false;
+        }
+        return true;
+    }
+    dispose() {
+        this.#closed = true;
+        void this.#worker?.terminate();
+        this.#worker = undefined;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+export type Json = null | boolean | number | string | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export type OmissionReason = "invalid_input" | "limit_exceeded" | "detector_failure" | "policy_invalid" | "cancelled" | "incomplete";
+export interface SanitizationSummary {
+    readonly version: 1;
+    readonly policy: string;
+    readonly coverage: "portable" | "credential-detectors";
+    readonly redacted: boolean;
+    readonly pathsNormalized: boolean;
+}
+export interface Sanitized<T> {
+    readonly status: "sanitized";
+    readonly value: T;
+    readonly summary: SanitizationSummary;
+}
+export interface Omission {
+    readonly status: "omitted";
+    readonly reason: OmissionReason;
+}
+export type Result<T> = Sanitized<T> | Omission;
+export interface Span {
+    readonly start: number;
+    readonly end: number;
+}
+export interface Detector {
+    /** Static reviewed inventory identity, never source or runtime diagnostics. */
+    readonly id: string;
+    scan(text: string): Promise<readonly Span[]>;
+}
+export interface TrustedRoot {
+    readonly kind: "workspace" | "home" | "temp";
+    readonly path: string;
+    readonly id?: string;
+    readonly repositoryId?: string;
+    readonly aliases?: readonly string[];
+    readonly caseSensitive?: boolean;
+}
+export type LogicalPath = Readonly<{
+    kind: "workspace";
+    workspaceId: string;
+    repositoryId?: string;
+    relativePath: string;
+    display: string;
+    resolvable: true;
+}> | Readonly<{
+    kind: "external";
+    display: string;
+    resolvable: false;
+}>;
+export interface Policy {
+    readonly secrets?: readonly string[];
+    readonly roots?: readonly TrustedRoot[];
+    readonly destination?: "private-portable" | "public";
+    readonly detector?: Detector;
+}
+export declare const LIMITS: Readonly<{
+    text: number;
+    record: number;
+    depth: 32;
+    secrets: 1024;
+    secretBytes: number;
+}>;
+export declare const REDACTED = "[REDACTED]";
+export declare const EXTERNAL = "[EXTERNAL_PATH]";
+export declare function omit(reason: OmissionReason): Omission;
+export declare function utf8Size(text: string): number;
+export declare function validUnicode(text: string): boolean;

package/dist/types.js

@@ -0,0 +1,18 @@
+export const LIMITS = Object.freeze({
+    text: 2 * 1024 * 1024,
+    record: 4 * 1024 * 1024,
+    depth: 32,
+    secrets: 1024,
+    secretBytes: 1024 * 1024,
+});
+export const REDACTED = "[REDACTED]";
+export const EXTERNAL = "[EXTERNAL_PATH]";
+export function omit(reason) {
+    return Object.freeze({ status: "omitted", reason });
+}
+export function utf8Size(text) {
+    return new TextEncoder().encode(text).byteLength;
+}
+export function validUnicode(text) {
+    return !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(text);
+}