@or3/intern-client 0.1.1

package/src/redaction.ts

@@ -0,0 +1,114 @@
+const REDACTED = '[REDACTED]';
+
+function secretKey(key: string): boolean {
+    return (
+        /^(?:authorization|proxy-authorization|cookie|set-cookie|password|passphrase|secret|api[_-]?key)$/i.test(
+            key
+        ) ||
+        /(?:^|[_-])(?:password|passphrase|secret|token|api[_-]?key)$/i.test(
+            key
+        ) ||
+        /(?:Password|Passphrase|Secret|Token|ApiKey)$/.test(key)
+    );
+}
+
+function replaceLiteral(value: string, secret: string): string {
+    if (!secret) return value;
+    return value.split(secret).join(REDACTED);
+}
+
+function redactString(
+    input: string,
+    explicitSecrets: readonly string[]
+): string {
+    let value = input
+        .replace(/\bBearer\s+[^\s"',;]+/gi, `Bearer ${REDACTED}`)
+        .replace(
+            /(["']?(?:authorization|api[_-]?key|[a-z0-9_-]*(?:password|passphrase|secret|token))["']?\s*[:=]\s*["']?)([^"',}\s&]+)/gi,
+            `$1${REDACTED}`
+        );
+
+    value = value.replace(
+        /([?&])([^=&#]+)=([^&#]*)/g,
+        (match, prefix: string, rawKey: string) => {
+            let key = rawKey;
+            try {
+                key = decodeURIComponent(rawKey);
+            } catch {
+                // Keep the raw key when malformed URL encoding is encountered.
+            }
+            return secretKey(key)
+                ? `${prefix}${rawKey}=${REDACTED}`
+                : match;
+        }
+    );
+
+    for (const secret of explicitSecrets) {
+        value = replaceLiteral(value, secret);
+    }
+    return value;
+}
+
+function redactValue(
+    value: unknown,
+    explicitSecrets: readonly string[],
+    seen: WeakSet<object>
+): unknown {
+    if (typeof value === 'string') {
+        return redactString(value, explicitSecrets);
+    }
+    if (
+        value === null ||
+        value === undefined ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint'
+    ) {
+        return value;
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: redactString(value.message, explicitSecrets),
+        };
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) return '[Circular]';
+        seen.add(value);
+        return value.map((item) => redactValue(item, explicitSecrets, seen));
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) return '[Circular]';
+        seen.add(value);
+        const output: Record<string, unknown> = {};
+        for (const [key, item] of Object.entries(value)) {
+            output[key] = secretKey(key)
+                ? REDACTED
+                : redactValue(item, explicitSecrets, seen);
+        }
+        return output;
+    }
+    return redactString(String(value), explicitSecrets);
+}
+
+export function redactInternSecrets(
+    value: unknown,
+    explicitSecrets: readonly string[] = []
+): unknown {
+    return redactValue(
+        value,
+        explicitSecrets.filter(Boolean),
+        new WeakSet()
+    );
+}
+
+export function safeInternStringify(
+    value: unknown,
+    explicitSecrets: readonly string[] = []
+): string {
+    try {
+        return JSON.stringify(redactInternSecrets(value, explicitSecrets));
+    } catch {
+        return '"[Unserializable]"';
+    }
+}

package/src/sse.ts

@@ -0,0 +1,151 @@
+export interface InternSseEvent<T = unknown> {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data: string;
+    json?: T;
+    cursor?: string;
+}
+
+function parseJson<T>(data: string): T | undefined {
+    if (!data) return undefined;
+    try {
+        return JSON.parse(data) as T;
+    } catch {
+        return undefined;
+    }
+}
+
+export function parseInternSseBlock<T = unknown>(
+    block: string
+): InternSseEvent<T> {
+    const data: string[] = [];
+    const output: InternSseEvent<T> = { data: '' };
+
+    for (const line of block.split(/\r\n|\r|\n/)) {
+        if (!line || line.startsWith(':')) continue;
+        const separator = line.indexOf(':');
+        const field = separator < 0 ? line : line.slice(0, separator);
+        const rawValue = separator < 0 ? '' : line.slice(separator + 1);
+        const value = rawValue.startsWith(' ')
+            ? rawValue.slice(1)
+            : rawValue;
+        switch (field) {
+            case 'event':
+                output.event = value;
+                break;
+            case 'id':
+                if (!value.includes('\0')) output.id = value;
+                break;
+            case 'retry': {
+                const retry = Number(value);
+                if (Number.isInteger(retry) && retry >= 0) {
+                    output.retry = retry;
+                }
+                break;
+            }
+            case 'data':
+                data.push(value);
+                break;
+        }
+    }
+
+    output.data = data.join('\n');
+    output.json = parseJson<T>(output.data);
+    if (output.id) output.cursor = output.id;
+    return output;
+}
+
+function splitSseBuffer(buffer: string): {
+    blocks: string[];
+    remainder: string;
+} {
+    const blocks: string[] = [];
+    let start = 0;
+    const delimiter = /\r\n\r\n|\n\n|\r\r/g;
+    for (let match = delimiter.exec(buffer); match; match = delimiter.exec(buffer)) {
+        blocks.push(buffer.slice(start, match.index));
+        start = match.index + match[0].length;
+    }
+    return { blocks, remainder: buffer.slice(start) };
+}
+
+export async function* readInternSseStream<T = unknown>(
+    stream: ReadableStream<Uint8Array>,
+    signal?: AbortSignal
+): AsyncIterable<InternSseEvent<T>> {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const abort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    signal?.addEventListener('abort', abort, { once: true });
+
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw signal.reason ?? new DOMException('Aborted', 'AbortError');
+            }
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const { blocks, remainder } = splitSseBuffer(buffer);
+            buffer = remainder;
+            for (const block of blocks) {
+                if (block.trim() && !block.trimStart().startsWith(':')) {
+                    yield parseInternSseBlock<T>(block);
+                }
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim() && !buffer.trimStart().startsWith(':')) {
+            yield parseInternSseBlock<T>(buffer);
+        }
+    } finally {
+        signal?.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+}
+
+export function internSseEventKey(
+    event: InternSseEvent<unknown>
+): string | undefined {
+    if (event.id) return `sse:${event.id}`;
+    const payload =
+        event.json && typeof event.json === 'object' && !Array.isArray(event.json)
+            ? (event.json as Record<string, unknown>)
+            : undefined;
+    if (!payload) return undefined;
+    if (
+        (typeof payload.id === 'string' || typeof payload.id === 'number') &&
+        String(payload.id) !== ''
+    ) {
+        return `payload:${String(payload.id)}`;
+    }
+    if (
+        typeof payload.turn_id === 'string' &&
+        (typeof payload.seq === 'string' || typeof payload.seq === 'number')
+    ) {
+        return `turn:${payload.turn_id}:${String(payload.seq)}`;
+    }
+    return undefined;
+}
+
+export function internSseEventCursor(
+    event: InternSseEvent<unknown>
+): string | undefined {
+    if (event.id) return event.id;
+    const payload =
+        event.json && typeof event.json === 'object' && !Array.isArray(event.json)
+            ? (event.json as Record<string, unknown>)
+            : undefined;
+    if (
+        payload &&
+        (typeof payload.seq === 'string' || typeof payload.seq === 'number')
+    ) {
+        return String(payload.seq);
+    }
+    return undefined;
+}