@cortexkit/common-auth 0.2.4 → 0.2.5

package/dist/dump/index.js

@@ -1,2 +1,292 @@
-// Placeholder so the export resolves until this subpath is built.
-export {};
+import { createHash } from 'node:crypto';
+import { chmod, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createRedactor } from '../logger/redact.js';
+const PREVIOUS_BODY_LIMIT = 100;
+const UNKNOWN_SESSION = 'session-unknown';
+function shortSession(session) {
+    return session.length <= 16 ? session : `${session.slice(0, 12)}…`;
+}
+function fileSegment(value, fallback) {
+    const normalized = value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!normalized)
+        return fallback;
+    return normalized.slice(0, 80);
+}
+function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function normalizeKey(key) {
+    return key.toLowerCase().replace(/[-_]/g, '');
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Where two bodies first and last differ, in string offsets into the dumped
+ * (redacted) text. Offsets count UTF-16 units, as the plugins' cache analysis
+ * always has.
+ */
+export function diffDumpBodies(previous, current) {
+    if (previous === undefined)
+        return null;
+    if (previous === current) {
+        return {
+            changed: false,
+            firstByte: -1,
+            lastPreviousByte: -1,
+            lastCurrentByte: -1,
+            previousBytes: previous.length,
+            currentBytes: current.length,
+        };
+    }
+    let firstByte = 0;
+    while (firstByte < previous.length &&
+        firstByte < current.length &&
+        previous[firstByte] === current[firstByte]) {
+        firstByte++;
+    }
+    let previousTail = previous.length - 1;
+    let currentTail = current.length - 1;
+    while (previousTail >= firstByte &&
+        currentTail >= firstByte &&
+        previous[previousTail] === current[currentTail]) {
+        previousTail--;
+        currentTail--;
+    }
+    return {
+        changed: true,
+        firstByte,
+        lastPreviousByte: previousTail,
+        lastCurrentByte: currentTail,
+        changedPreviousBytes: previousTail - firstByte + 1,
+        changedCurrentBytes: currentTail - firstByte + 1,
+        previousBytes: previous.length,
+        currentBytes: current.length,
+    };
+}
+export function createDumper(options) {
+    let enabled = options.enabled === true;
+    let counter = 0;
+    const pid = options.pid ?? process.pid;
+    const now = options.now ?? Date.now;
+    const log = options.logger;
+    const extraKeys = new Set((options.secretKeys ?? []).map(normalizeKey));
+    const redactor = createRedactor({
+        extraSecretKeys: (normalized) => extraKeys.has(normalized),
+        extraValuePatterns: [...(options.secretPatterns ?? [])],
+    });
+    const schemaKeys = new Set(options.schemaKeys ?? ['tools']);
+    /**
+     * Last dumped (redacted) body per baseline key, in memory for this process.
+     * A key missing here, on its first dump or after eviction, is looked up on
+     * disk.
+     */
+    const previousBodies = new Map();
+    const resolveDir = () => typeof options.dir === 'function' ? options.dir() : options.dir;
+    /** The mask for a secret key name, or undefined for an ordinary key. */
+    function maskFor(key) {
+        // The shared redactor masks a secret key whatever its value, so probing it
+        // with null answers "is this key a secret" without duplicating its rules.
+        const masked = redactor.redact({ [key]: null })[key];
+        return masked === null ? undefined : masked;
+    }
+    /**
+     * Redact by key name and scrub token-shaped strings, except below a schema
+     * key, where only strings are scrubbed: a tool parameter named `api_key`
+     * declares what the tool accepts, and masking that node would leave a
+     * schema that no longer parses. Key order is kept because dumps are diffed
+     * against each other.
+     */
+    function scrub(value) {
+        if (Array.isArray(value))
+            return value.map(scrub);
+        if (isRecord(value)) {
+            const out = {};
+            for (const [key, entry] of Object.entries(value)) {
+                const mask = maskFor(key);
+                if (schemaKeys.has(key))
+                    out[key] = redactor.redactStrings(entry);
+                else if (mask !== undefined)
+                    out[key] = mask;
+                else
+                    out[key] = scrub(entry);
+            }
+            return out;
+        }
+        return redactor.redactStrings(value);
+    }
+    function scrubBody(bodyText) {
+        let parsed;
+        try {
+            parsed = JSON.parse(bodyText);
+        }
+        catch {
+            // Not JSON: no keys to judge, but token-shaped strings still go.
+            return {
+                text: redactor.redactStrings(bodyText),
+                parsed: undefined,
+            };
+        }
+        const scrubbed = scrub(parsed);
+        const scrubbedText = JSON.stringify(scrubbed);
+        // Nothing redacted: keep the original bytes, whitespace included, so the
+        // dump is exactly what was sent.
+        const text = JSON.stringify(parsed) === scrubbedText ? bodyText : scrubbedText;
+        return { text, parsed: isRecord(scrubbed) ? scrubbed : undefined };
+    }
+    /**
+     * The newest earlier dump of this baseline key, read back from the dump
+     * directory. The in-memory baseline dies with the process, and the first
+     * request after a restart is the one most likely to break the prompt cache,
+     * so it is the one whose diff matters most. Reading the dumps themselves
+     * needs no extra state, and clearing the directory clears the baseline with
+     * it. Any failure is no baseline.
+     */
+    async function recoverBaseline(dir, session, channel, baselineKey) {
+        const marker = `-${fileSegment(session, UNKNOWN_SESSION)}-${fileSegment(channel, 'channel')}`;
+        let names;
+        try {
+            names = await readdir(dir);
+        }
+        catch {
+            return undefined;
+        }
+        // Names start with an ISO timestamp, so reverse lexicographic order is
+        // newest first. The metadata's key decides the match: a filename segment
+        // is truncated and sanitised, so two sessions can share one.
+        const candidates = names
+            .filter((name) => name.endsWith('.meta.json') && name.includes(marker))
+            .sort()
+            .reverse();
+        for (const name of candidates) {
+            try {
+                const metadata = JSON.parse(await readFile(join(dir, name), 'utf8'));
+                if (metadata?.baselineKey !== baselineKey)
+                    continue;
+                return await readFile(join(dir, name.replace(/\.meta\.json$/, '.body.json')), 'utf8');
+            }
+            catch {
+                // A file removed or half-written by another process: try the next.
+            }
+        }
+        return undefined;
+    }
+    function remember(key, text) {
+        if (!previousBodies.has(key)) {
+            while (previousBodies.size >= PREVIOUS_BODY_LIMIT) {
+                const oldest = previousBodies.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                previousBodies.delete(oldest);
+            }
+        }
+        previousBodies.set(key, text);
+    }
+    async function dump(input) {
+        if (!enabled)
+            return undefined;
+        counter++;
+        const session = input.session?.trim() || UNKNOWN_SESSION;
+        const dir = resolveDir();
+        const createdAt = new Date(now()).toISOString();
+        // The pid makes names unique across processes: each process starts its
+        // counter at zero, so two processes dumping the same session in the same
+        // millisecond into a shared directory would otherwise pick the same name.
+        const id = [
+            createdAt.replace(/[:.]/g, '-'),
+            String(pid),
+            String(counter).padStart(6, '0'),
+            fileSegment(session, UNKNOWN_SESSION),
+            fileSegment(input.channel, 'channel'),
+            ...(input.phase ? [fileSegment(input.phase, 'phase')] : []),
+        ].join('-');
+        const prefix = join(dir, id);
+        const files = {
+            body: `${prefix}.body.json`,
+            metadata: `${prefix}.meta.json`,
+            request: `${prefix}.request.json`,
+        };
+        // Hashed so the metadata identifies the baseline without spelling out the
+        // full session id.
+        const baselineKey = hashText(`${input.channel}\u0000${session}`);
+        try {
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            // mkdir's mode does not apply to a directory that already exists.
+            await chmod(dir, 0o700);
+            let previous = previousBodies.get(baselineKey);
+            let baselineSource = previous === undefined ? undefined : 'memory';
+            if (previous === undefined) {
+                previous = await recoverBaseline(dir, session, input.channel, baselineKey);
+                if (previous !== undefined)
+                    baselineSource = 'disk';
+            }
+            const body = scrubBody(input.bodyText);
+            const metadata = {
+                id,
+                createdAt,
+                pid,
+                session: shortSession(session),
+                channel: input.channel,
+                ...(input.phase ? { phase: input.phase } : {}),
+                accountId: input.accountId,
+                status: input.status,
+                error: input.error === undefined
+                    ? undefined
+                    : redactor.redactStrings(input.error),
+                baselineKey,
+                bodyBytes: Buffer.byteLength(input.bodyText, 'utf8'),
+                bodyHash: hashText(input.bodyText),
+                // Diffed on the redacted text that lands in the body file, so offsets
+                // index the file an operator can open, and a baseline read back from
+                // disk (also redacted) compares like with like.
+                diff: diffDumpBodies(previous, body.text),
+                baselineSource,
+                body: body.parsed
+                    ? { parseable: true, ...options.summarize?.(body.parsed) }
+                    : { parseable: false },
+                ...(input.meta ? { extra: scrub(input.meta) } : {}),
+                files,
+            };
+            const request = scrub({
+                url: input.url,
+                method: input.method,
+                accountId: input.accountId,
+                headers: input.headers === undefined
+                    ? undefined
+                    : Object.fromEntries(new Headers(input.headers).entries()),
+            });
+            // `wx`: a name collision fails loudly instead of overwriting a dump.
+            const write = (path, text) => writeFile(path, text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            await Promise.all([
+                write(files.body, body.text),
+                write(files.metadata, `${JSON.stringify(metadata, null, 2)}\n`),
+                write(files.request, `${JSON.stringify(request, null, 2)}\n`),
+            ]);
+            remember(baselineKey, body.text);
+            log?.debug('dumped request', {
+                id,
+                session: shortSession(session),
+                body: files.body,
+            });
+            return { id, files };
+        }
+        catch (error) {
+            log?.warn('request dump failed', {
+                session: shortSession(session),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
+        }
+    }
+    return {
+        isEnabled: () => enabled,
+        setEnabled: (value) => {
+            enabled = value;
+        },
+        dump,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/common-auth",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Shared code for the CortexKit auth plugins: account pool, quota and routing, commands and auth menu, OpenCode 2 hooks, Claustrum custody, and plumbing (loopback RPC, file locks, logger, sidebar state, TUI preferences and build).",
   "license": "MIT",
   "repository": {