The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(logger): redact passwords and tokens from HTTP error log lines (#8013)
Devin Foleybb7978327ed5
diff --git a/server/src/__tests__/redact-sensitive.test.ts b/server/src/__tests__/redact-sensitive.test.tsnew file mode 100644index 0000000000..173fbece82--- /dev/null+++ b/server/src/__tests__/redact-sensitive.test.ts@@ -0,0 +1,92 @@+import { describe, expect, it } from "vitest";+import { redactSensitive } from "../middleware/redact-sensitive.js";++describe("redactSensitive", () => {+ it("redacts a plaintext password field on a sign-in body", () => {+ const body = { email: "[email protected]", password: "founding6gomez6croaking" };++ const out = redactSensitive(body) as Record<string, unknown>;++ expect(out.email).toBe("[email protected]");+ expect(out.password).toBe("[REDACTED]");+ expect((body as Record<string, unknown>).password).toBe("founding6gomez6croaking");+ });++ it("redacts password key regardless of casing", () => {+ expect((redactSensitive({ Password: "x" }) as Record<string, unknown>).Password).toBe("[REDACTED]");+ expect((redactSensitive({ PASSWORD: "x" }) as Record<string, unknown>).PASSWORD).toBe("[REDACTED]");+ });++ it("redacts known credential-shaped keys", () => {+ const out = redactSensitive({+ currentPassword: "a",+ newPassword: "b",+ access_token: "c",+ refresh_token: "d",+ api_key: "e",+ authorization: "Bearer f",+ }) as Record<string, string>;++ for (const value of Object.values(out)) {+ expect(value).toBe("[REDACTED]");+ }+ });++ it("does not redact a bare `token` field — pagination cursors and CSRF tokens are not credentials", () => {+ const out = redactSensitive({ token: "next-page-cursor", limit: 20 }) as Record<string, unknown>;++ expect(out.token).toBe("next-page-cursor");+ expect(out.limit).toBe(20);+ });++ it("recurses into nested objects and arrays", () => {+ const out = redactSensitive({+ user: { email: "[email protected]", password: "secret-pass" },+ tokens: [{ access_token: "t1" }, { access_token: "t2" }],+ }) as Record<string, unknown>;++ expect((out.user as Record<string, unknown>).email).toBe("[email protected]");+ expect((out.user as Record<string, unknown>).password).toBe("[REDACTED]");+ const tokens = out.tokens as Array<Record<string, unknown>>;+ expect(tokens[0].access_token).toBe("[REDACTED]");+ expect(tokens[1].access_token).toBe("[REDACTED]");+ });++ it("leaves primitives and non-sensitive keys untouched", () => {+ const body = { email: "[email protected]", name: "Alice", count: 7, active: true, missing: null };++ expect(redactSensitive(body)).toEqual(body);+ });++ it("returns primitives unchanged", () => {+ expect(redactSensitive("hello")).toBe("hello");+ expect(redactSensitive(42)).toBe(42);+ expect(redactSensitive(null)).toBe(null);+ expect(redactSensitive(undefined)).toBe(undefined);+ });++ it("caps recursion depth so cycles do not pin the logger", () => {+ const cycle: Record<string, unknown> = { name: "root" };+ cycle.self = cycle;++ expect(() => redactSensitive(cycle)).not.toThrow();+ });++ it("omits deeply-nested arrays at the depth cap instead of leaking null entries to JSON", () => {+ // Build an object whose array field is reached at MAX_DEPTH. Recursing+ // into the array elements would exceed the cap; without the array-level+ // guard, `value.map` would produce `[undefined, ...]` which JSON.stringify+ // renders as `[null, ...]`. Object properties at the same cap are+ // already absent from the JSON output (JSON.stringify skips undefined+ // values on objects), so this test pins the array path to the same+ // contract: silently absent, not visible as nulls.+ let payload: Record<string, unknown> = { values: [1, 2, 3] };+ for (let i = 0; i < 5; i++) payload = { nested: payload };++ const out = redactSensitive(payload);++ const json = JSON.stringify(out);+ expect(json).not.toContain("null");+ expect(json).not.toContain("[1,2,3]");+ });+});diff --git a/server/src/middleware/logger.ts b/server/src/middleware/logger.tsindex 7eb5c2b434..e014a34ca6 100644--- a/server/src/middleware/logger.ts+++ b/server/src/middleware/logger.ts@@ -5,6 +5,7 @@ import { pinoHttp } from "pino-http";import { readConfigFile } from "../config-file.js";import { resolveDefaultLogsDir, resolveHomeAwarePath } from "../home-paths.js";import { shouldSilenceHttpSuccessLog } from "./http-log-policy.js";+import { redactSensitive } from "./redact-sensitive.js";function resolveServerLogDir(): string {const envOverride = process.env.PAPERCLIP_LOG_DIR?.trim();@@ -69,21 +70,21 @@ export const httpLogger = pinoHttp({if (ctx) {return {errorContext: ctx.error,- reqBody: ctx.reqBody,- reqParams: ctx.reqParams,- reqQuery: ctx.reqQuery,+ reqBody: redactSensitive(ctx.reqBody),+ reqParams: redactSensitive(ctx.reqParams),+ reqQuery: redactSensitive(ctx.reqQuery),};}const props: Record<string, unknown> = {};const { body, params, query } = req as any;if (body && typeof body === "object" && Object.keys(body).length > 0) {- props.reqBody = body;+ props.reqBody = redactSensitive(body);}if (params && typeof params === "object" && Object.keys(params).length > 0) {- props.reqParams = params;+ props.reqParams = redactSensitive(params);}if (query && typeof query === "object" && Object.keys(query).length > 0) {- props.reqQuery = query;+ props.reqQuery = redactSensitive(query);}if ((req as any).route?.path) {props.routePath = (req as any).route.path;diff --git a/server/src/middleware/redact-sensitive.ts b/server/src/middleware/redact-sensitive.tsnew file mode 100644index 0000000000..4b7247a42d--- /dev/null+++ b/server/src/middleware/redact-sensitive.ts@@ -0,0 +1,67 @@+// Redaction for HTTP log payloads.+//+// `customProps` in logger.ts copies `req.body` / `req.params` / `req.query`+// verbatim into the 4xx/5xx log lines so operators can diagnose. That means+// Better Auth's `POST /api/auth/sign-in/email` body (which has the user's+// plaintext password) and similar payloads (sign-up, reset-password, API+// keys via Authorization header equivalents) end up on disk.+//+// This walker returns a shallow copy of the input with values for sensitive+// keys replaced with the literal string "[REDACTED]". Recurses into nested+// objects/arrays. Caps depth so a hostile or accidental cycle can't pin+// the logger.++const SENSITIVE_KEYS = new Set<string>([+ "password",+ "currentpassword",+ "newpassword",+ "passwordconfirmation",+ "password_confirmation",+ "passwordconfirm",+ "password_confirm",+ "confirmpassword",+ "confirm_password",+ "secret",+ "client_secret",+ "clientsecret",+ "access_token",+ "accesstoken",+ "refresh_token",+ "refreshtoken",+ "id_token",+ "idtoken",+ "api_key",+ "apikey",+ "authorization",+ "auth_token",+ "authtoken",+ "session_token",+ "sessiontoken",+ "private_key",+ "privatekey",+]);++const MAX_DEPTH = 6;+const REDACTED = "[REDACTED]";++function isSensitiveKey(key: string): boolean {+ return SENSITIVE_KEYS.has(key.toLowerCase());+}++export function redactSensitive(value: unknown, depth = 0): unknown {+ if (depth > MAX_DEPTH) return undefined;+ if (value === null || typeof value !== "object") return value;+ if (Array.isArray(value)) {+ if (depth + 1 > MAX_DEPTH) return undefined;+ return value.map((entry) => redactSensitive(entry, depth + 1));+ }+ const out: Record<string, unknown> = {};+ for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {+ if (isSensitiveKey(key)) {+ out[key] = REDACTED;+ continue;+ }+ out[key] = redactSensitive(entry, depth + 1);+ }+ return out;+}