@gajae-code/ai 0.13.2 → 0.14.0

package/src/auth-broker/server.ts

@@ -10,12 +10,15 @@
  * the server only checks a bearer token against an allow-list per request.
  */
 import { logger } from "@gajae-code/utils";
+import { timingSafeEqual } from "../auth-gateway/http";
 import type { AuthStorage } from "../auth-storage";
-import { parseBind } from "../utils/parse-bind";
+import { assertAuthenticatedOrLoopback, parseBind } from "../utils/parse-bind";
+import { cleanReason } from "./redact";
 import { AuthBrokerRefresher, type AuthBrokerRefresherSchedule } from "./refresher";
 import type {
 	CredentialDisableResponse,
 	CredentialIfAbsentUploadResponse,
+	CredentialMetadataResponse,
 	CredentialRefreshRequest,
 	CredentialRefreshResponse,
 	CredentialUploadResponse,
@@ -88,7 +91,13 @@ function isAuthorized(req: Request, tokens: ReadonlySet<string>): boolean {
 	if (!header) return false;
 	const match = header.match(/^Bearer\s+(.+)$/i);
 	if (!match) return false;
-	return tokens.has(match[1].trim());
+	const presented = new TextEncoder().encode(match[1].trim());
+	let ok = false;
+	for (const token of tokens) {
+		const expected = new TextEncoder().encode(token);
+		if (timingSafeEqual(presented, expected)) ok = true;
+	}
+	return ok;
 }
 
 /**
@@ -105,7 +114,12 @@ async function parseBody<T>(
 	try {
 		raw = await req.text();
 	} catch (error) {
-		return { ok: false, response: json(400, { error: `Invalid request body: ${String(error)}` }) };
+		return {
+			ok: false,
+			response: json(400, {
+				error: `Invalid request body: ${cleanReason(error) ?? "request body could not be read"}`,
+			}),
+		};
 	}
 	if (raw.length === 0 && !options.allowEmpty) {
 		return { ok: false, response: json(400, { error: "Request body required" }) };
@@ -114,7 +128,12 @@ async function parseBody<T>(
 	try {
 		parsed = raw.length === 0 ? {} : JSON.parse(raw);
 	} catch (error) {
-		return { ok: false, response: json(400, { error: `Invalid JSON body: ${String(error)}` }) };
+		return {
+			ok: false,
+			response: json(400, {
+				error: `Invalid JSON body: ${cleanReason(error) ?? "request body could not be parsed"}`,
+			}),
+		};
 	}
 	const result = schema.safeParse(parsed);
 	if (!result.success) {
@@ -284,6 +303,22 @@ function buildSnapshot(storage: AuthStorage, refresher: AuthBrokerRefresher | un
 	};
 }
 
+/** Build the payload-free credential inventory projection for the metadata route. */
+function buildCredentialMetadata(storage: AuthStorage): CredentialMetadataResponse {
+	const credentials = storage.listCredentialInventory().map(record => ({
+		id: record.id,
+		provider: record.provider,
+		type: record.credentialKind,
+		identity: record.identityLabel,
+		disabledCause: record.disabledCause,
+	}));
+	return {
+		generation: storage.getGeneration(),
+		generatedAt: Date.now(),
+		credentials,
+	};
+}
+
 async function serveSnapshot(
 	req: Request,
 	url: URL,
@@ -505,6 +540,7 @@ function serveSnapshotStream(
 export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServerHandle {
 	const bind = parseBind(opts.bind ?? DEFAULT_AUTH_BROKER_BIND);
 	const tokens = new Set<string>(opts.bearerTokens);
+	assertAuthenticatedOrLoopback(bind, tokens.size, "auth-broker");
 	const version = opts.version;
 	const streamKeepaliveMs = opts.streamKeepaliveMs ?? DEFAULT_STREAM_KEEPALIVE_MS;
 
@@ -536,6 +572,15 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 					logger.info("auth-broker request unauthorized", { method: req.method, path: pathname, peer });
 					return json(401, { error: "unauthorized" });
 				}
+				if (req.method === "GET" && pathname === "/v1/credentials/metadata") {
+					await opts.storage.reload();
+					const body = buildCredentialMetadata(opts.storage);
+					logger.info("auth-broker credential metadata served", {
+						generation: body.generation,
+						status: "ok",
+					});
+					return json(200, body);
+				}
 				if (req.method === "GET" && pathname === "/v1/snapshot/stream") {
 					return serveSnapshotStream(req, opts.storage, refresher, peer, streamKeepaliveMs);
 				}
@@ -557,7 +602,7 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						logger.info("auth-broker usage served", { peer, reports: trimmed.length });
 						return json(200, { generatedAt: Date.now(), reports: trimmed });
 					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
+						const message = cleanReason(error) ?? "Usage fetch failed";
 						logger.warn("auth-broker usage fetch failed", { peer, error: message });
 						return json(502, { error: message });
 					}
@@ -579,9 +624,9 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						});
 						return json(200, body);
 					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
+						const message = cleanReason(error) ?? "Credential refresh failed";
 						logger.warn("auth-broker refresh failed", { id, peer, error: message });
-						const status = message.includes("No credential with id") ? 404 : 500;
+						const status = message.startsWith("No credential with id") ? 404 : 500;
 						return json(status, { error: message });
 					}
 				}
@@ -594,10 +639,10 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						parsed.data.cause && parsed.data.cause.length > 0 ? parsed.data.cause : "disabled via auth-broker";
 					const ok = opts.storage.disableCredentialById(id, cause);
 					if (!ok) {
-						logger.info("auth-broker disable miss", { id, peer, cause });
+						logger.info("auth-broker disable miss", { id, peer });
 						return json(404, { error: `No credential with id=${id}` });
 					}
-					logger.info("auth-broker credential disabled", { id, peer, cause });
+					logger.info("auth-broker credential disabled", { id, peer });
 					const response: CredentialDisableResponse = { ok: true };
 					return json(200, response);
 				}
@@ -622,7 +667,7 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						};
 						return json(200, response);
 					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
+						const message = cleanReason(error) ?? "Credential import failed";
 						logger.warn("auth-broker upload-if-absent failed", { provider, type: credential.type, peer });
 						return json(500, { error: message });
 					}
@@ -647,7 +692,7 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						const response: CredentialUploadResponse = { entries };
 						return json(200, response);
 					} catch (error) {
-						const message = error instanceof Error ? error.message : String(error);
+						const message = cleanReason(error) ?? "Credential upload failed";
 						logger.warn("auth-broker upload failed", { provider, peer, error: message });
 						return json(500, { error: message });
 					}
@@ -657,7 +702,7 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 				logger.error("auth-broker handler crashed", {
 					method: req.method,
 					path: pathname,
-					error: String(error),
+					error: cleanReason(error) ?? "internal error",
 				});
 				return json(500, { error: "internal error" });
 			}

package/src/auth-broker/types.ts

@@ -15,6 +15,22 @@ import type {
 } from "../auth-storage";
 import type { UsageReport } from "../usage";
 
+/** A single credential metadata projection; secret-bearing fields are intentionally absent. */
+export interface CredentialMetadataRecord {
+	id: number;
+	provider: string;
+	type: "oauth" | "api_key";
+	identity: string | null;
+	disabledCause: string | null;
+}
+
+/** GET /v1/credentials/metadata response body. */
+export interface CredentialMetadataResponse {
+	generation: number;
+	generatedAt: number;
+	credentials: CredentialMetadataRecord[];
+}
+
 /** GET /v1/healthz response body. */
 export interface HealthzResponse {
 	ok: boolean;

package/src/auth-broker/wire-schemas.ts

@@ -109,6 +109,27 @@ export const snapshotResponseSchema = z
 	})
 	.strict();
 
+// ─── Credential metadata ───────────────────────────────────────────────────
+
+/** Closed redacted projection: no token, key, identity object, or extension fields. */
+export const credentialMetadataRecordSchema = z
+	.object({
+		id: z.number().int(),
+		provider: z.string().min(1),
+		type: z.enum(["oauth", "api_key"]),
+		identity: z.string().nullable(),
+		disabledCause: z.string().nullable(),
+	})
+	.strict();
+
+export const credentialMetadataResponseSchema = z
+	.object({
+		generation: z.number().int().nonnegative(),
+		generatedAt: z.number().finite().nonnegative(),
+		credentials: z.array(credentialMetadataRecordSchema),
+	})
+	.strict();
+
 // ─── Snapshot stream (SSE) ────────────────────────────────────────────────
 
 /** First frame on connect — full snapshot embedded inline with a `kind` tag. */

package/src/auth-gateway/server.ts

@@ -19,6 +19,7 @@
  */
 
 import { logger } from "@gajae-code/utils";
+import { cleanReason } from "../auth-broker/redact";
 import type { AuthStorage } from "../auth-storage";
 import { Effort } from "../model-thinking";
 import * as anthropicMessages from "../providers/anthropic-messages-server";
@@ -26,9 +27,17 @@ import * as openaiChat from "../providers/openai-chat-server";
 import * as openaiResponses from "../providers/openai-responses-server";
 import * as piNative from "../providers/pi-native-server";
 import { streamSimple } from "../stream";
-import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "../types";
+import type {
+	Api,
+	AssistantMessage,
+	AssistantMessageEvent,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	SimpleStreamOptions,
+} from "../types";
 import { beginAttempt, classifyFallbackTrigger } from "../utils/fallback-transport";
-import { parseBind } from "../utils/parse-bind";
+import { assertAuthenticatedOrLoopback, parseBind } from "../utils/parse-bind";
 import {
 	captureRequestHeaders,
 	corsHeaders,
@@ -204,8 +213,9 @@ function buildStreamOptions(parsed: ParsedFormatRequest, api: Api, signal: Abort
  * format emits its native envelope shape.
  */
 function classifyGatewayError(err: unknown): { status: number; type: string; message: string } {
-	const message = err instanceof Error ? err.message : String(err);
-	const lower = message.toLowerCase();
+	const rawMessage = err instanceof Error ? err.message : String(err);
+	const message = cleanReason(rawMessage) ?? "Upstream request failed";
+	const lower = rawMessage.toLowerCase();
 
 	// Custom pi-ai errors may attach a numeric `status` property; honor it
 	// when present and pick the matching tag.
@@ -242,6 +252,48 @@ function classifyGatewayError(err: unknown): { status: number; type: string; mes
 	return { status: 502, type: "upstream_error", message };
 }
 
+function redactGatewayError(error: unknown): Error {
+	const redacted = new Error(cleanReason(error) ?? "Upstream request failed");
+	if (error instanceof Error) {
+		redacted.name = error.name;
+		const status = (error as { status?: unknown }).status;
+		if (typeof status === "number") (redacted as Error & { status: number }).status = status;
+	}
+	return redacted;
+}
+
+function redactGatewayMessage(message: AssistantMessage): AssistantMessage {
+	if (message.errorMessage === undefined) return message;
+	return { ...message, errorMessage: cleanReason(message.errorMessage) ?? "Upstream request failed" };
+}
+
+/**
+ * Protect all gateway SSE encoders from upstream error text. Provider wire
+ * modules format `error` events themselves, so sanitize at this boundary and
+ * also convert iterator failures to bounded errors before their catch blocks.
+ */
+function redactGatewayStream(events: AssistantMessageEventStream): AssistantMessageEventStream {
+	async function* redactedEvents(): AsyncGenerator<AssistantMessageEvent> {
+		try {
+			for await (const event of events) {
+				if (event.type === "error") yield { ...event, error: redactGatewayMessage(event.error) };
+				else yield event;
+			}
+		} catch (error) {
+			throw redactGatewayError(error);
+		}
+	}
+	const result = redactedEvents() as unknown as AssistantMessageEventStream;
+	result.result = async () => {
+		try {
+			return redactGatewayMessage(await events.result());
+		} catch (error) {
+			throw redactGatewayError(error);
+		}
+	};
+	return result;
+}
+
 async function refreshGatewayApiKeyAfterAuthError(
 	storage: AuthStorage,
 	model: Model<Api>,
@@ -257,7 +309,7 @@ async function refreshGatewayApiKeyAfterAuthError(
 		format,
 		provider,
 		peer,
-		error: error instanceof Error ? error.message : String(error),
+		error: cleanReason(error) ?? "Upstream request failed",
 	});
 	return storage.getApiKey(provider, undefined, { modelId: model.id, signal });
 }
@@ -308,7 +360,7 @@ async function markManagedGatewayCredentialFailure(
 			format,
 			provider: model.provider,
 			peer,
-			error: markError instanceof Error ? markError.message : String(markError),
+			error: cleanReason(markError) ?? "Credential bookkeeping failed",
 		});
 	}
 }
@@ -382,7 +434,11 @@ async function handleFormatEndpoint(
 		body = await req.json();
 	} catch (error) {
 		if (controller.signal.aborted) return clientClosedResponse(route);
-		return route.module.formatError(400, "invalid_request_error", `Invalid JSON body: ${String(error)}`);
+		return route.module.formatError(
+			400,
+			"invalid_request_error",
+			`Invalid JSON body: ${cleanReason(error) ?? "request body could not be parsed"}`,
+		);
 	}
 	if (controller.signal.aborted) return clientClosedResponse(route);
 
@@ -438,7 +494,7 @@ async function handleFormatEndpoint(
 		parsed = route.module.parseRequest(body, req.headers);
 	} catch (error) {
 		if (controller.signal.aborted) return clientClosedResponse(route);
-		const message = error instanceof Error ? error.message : String(error);
+		const message = cleanReason(error) ?? "Request validation failed";
 		return route.module.formatError(400, "invalid_request_error", message);
 	}
 	// Merge gateway-captured passthrough headers under the parser's own
@@ -511,6 +567,7 @@ async function handleFormatEndpoint(
 			),
 		);
 	}
+	events = redactGatewayStream(events);
 
 	if (!parsed.stream) {
 		try {
@@ -520,17 +577,18 @@ async function handleFormatEndpoint(
 				const errorMessage =
 					message.errorMessage ??
 					(message.stopReason === "aborted" ? "Request was aborted" : "Upstream request failed");
+				const safeErrorMessage = cleanReason(errorMessage) ?? "Upstream request failed";
 				logger.warn("auth-gateway non-streaming failed", {
 					format: route.label,
 					reason: message.stopReason,
-					error: errorMessage,
+					error: safeErrorMessage,
 					peer,
 				});
 				if (message.stopReason === "aborted") {
-					return route.module.formatError(499, "request_aborted", errorMessage);
+					return route.module.formatError(499, "request_aborted", safeErrorMessage);
 				}
-				const classified = classifyGatewayError(new Error(errorMessage));
-				return route.module.formatError(classified.status, classified.type, errorMessage);
+				const classified = classifyGatewayError(new Error(safeErrorMessage));
+				return route.module.formatError(classified.status, classified.type, classified.message);
 			}
 			return json(200, route.module.encodeResponse(message, parsed.modelId));
 		} catch (error) {
@@ -585,7 +643,11 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 		body = await req.json();
 	} catch (error) {
 		if (controller.signal.aborted) return aborted();
-		return piNative.formatError(400, "invalid_request_error", `Invalid JSON body: ${String(error)}`);
+		return piNative.formatError(
+			400,
+			"invalid_request_error",
+			`Invalid JSON body: ${cleanReason(error) ?? "request body could not be parsed"}`,
+		);
 	}
 	if (controller.signal.aborted) return aborted();
 
@@ -594,7 +656,7 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 		parsed = piNative.parseRequest(body, req.headers);
 	} catch (error) {
 		if (controller.signal.aborted) return aborted();
-		const message = error instanceof Error ? error.message : String(error);
+		const message = cleanReason(error) ?? "Request validation failed";
 		return piNative.formatError(400, "invalid_request_error", message);
 	}
 
@@ -699,6 +761,7 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 			),
 		);
 	}
+	events = redactGatewayStream(events);
 
 	if (!parsed.stream) {
 		try {
@@ -708,17 +771,18 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 				const errorMessage =
 					message.errorMessage ??
 					(message.stopReason === "aborted" ? "Request was aborted" : "Upstream request failed");
+				const safeErrorMessage = cleanReason(errorMessage) ?? "Upstream request failed";
 				logger.warn("auth-gateway non-streaming failed", {
 					format: "pi-native",
 					reason: message.stopReason,
-					error: errorMessage,
+					error: safeErrorMessage,
 					peer,
 				});
 				if (message.stopReason === "aborted") {
-					return piNative.formatError(499, "request_aborted", errorMessage);
+					return piNative.formatError(499, "request_aborted", safeErrorMessage);
 				}
-				const classified = classifyGatewayError(new Error(errorMessage));
-				return piNative.formatError(classified.status, classified.type, errorMessage);
+				const classified = classifyGatewayError(new Error(safeErrorMessage));
+				return piNative.formatError(classified.status, classified.type, classified.message);
 			}
 			return json(200, { message });
 		} catch (error) {
@@ -787,6 +851,7 @@ function handleModelsList(opts: AuthGatewayBootOptions): Response {
 export function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServerHandle {
 	const bind = parseBind(opts.bind ?? DEFAULT_AUTH_GATEWAY_BIND);
 	const tokens = new Set<string>(opts.bearerTokens);
+	assertAuthenticatedOrLoopback(bind, tokens.size, "auth-gateway");
 	const version = opts.version;
 
 	const server = Bun.serve({
@@ -859,7 +924,7 @@ export function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServe
 					method: req.method,
 					path: pathname,
 					peer,
-					error: String(error),
+					error: cleanReason(error) ?? "internal error",
 				});
 				return withCors(json(500, { error: "internal error" }), req);
 			}