@apifuse/provider-sdk 2.2.0-beta.59 → 2.2.0-beta.61

package/src/provider.ts

@@ -18,14 +18,6 @@ export type {
 	DefinedCredentialsAuth,
 } from "./auth.js";
 export { createFormCeremony } from "./ceremonies/index.js";
-export {
-	assertFreshProviderChoiceIssuedAt,
-	createProviderChoiceToken,
-	ProviderChoiceTokenError,
-	type ProviderChoiceTokenErrorReason,
-	type ProviderChoiceTokenPayload,
-	parseProviderChoiceToken,
-} from "./choice-token.js";
 export {
 	centered,
 	delayed,
@@ -161,12 +153,16 @@ export {
 	providerLocaleKey,
 	qualifyProviderLocaleKey,
 } from "./i18n/index.js";
+export * from "./handle.js";
 export {
-	type CreateProviderChoiceContextOptions,
-	createProviderChoiceContext,
-	createTestProviderChoiceContext,
-	PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
-} from "./runtime/choice.js";
+	type CreateHandleContextOptions,
+	type CreateTestHandleContextOptions,
+	createHandleContext,
+	createTestHandleContext,
+	type HandleNormalizationClass,
+	type NormalizedHandle,
+	normalizeHandle,
+} from "./runtime/handle.js";
 export {
 	APIFUSE_CONTENT_PROVENANCE_META_KEY,
 	APIFUSE_CONTENT_TRUST_META_KEY,
@@ -179,6 +175,7 @@ export {
 	field,
 	fields,
 	isSensitiveSchema,
+	publicField,
 	redactPayload,
 	type SensitiveFieldKind,
 	type SensitiveFieldOptions,
@@ -244,13 +241,6 @@ export type {
 	OperationSensitivePath,
 	OperationTransport,
 	ProviderAccessVisibility,
-	ProviderChoiceBindingOptions,
-	ProviderChoiceConsumeMode,
-	ProviderChoiceConsumeResult,
-	ProviderChoiceContext,
-	ProviderChoiceExplicitParseResult,
-	ProviderChoiceIssueOptions,
-	ProviderChoiceParseOptions,
 	ProviderContext,
 	ProviderContextFor,
 	ProviderDefinition,

package/src/runtime/browser.ts

@@ -1,3 +1,4 @@
+import { readDiagnosticEnv } from "./diagnostic-env.js";
 import { createRequire } from "node:module";
 import type { CDPSession, Frame, LaunchOptions, Locator, Page, Request, Route } from "playwright";
 
@@ -495,7 +496,7 @@ type SupportedBrowserClient = {
 };
 
 function getDefaultCdpPoolUrl(env = process.env): string | undefined {
-	return env.APIFUSE__CDP_POOL__URL;
+	return readDiagnosticEnv("APIFUSE__CDP_POOL__URL", env);
 }
 
 async function importOptionalModule<T extends object>(moduleName: string): Promise<T> {

package/src/runtime/cache.ts

@@ -1,3 +1,4 @@
+import { readDiagnosticEnv } from "./diagnostic-env.js";
 import { createHash, createHmac } from "node:crypto";
 
 import { providerCacheRedisUrlFromEnv } from "../config/loader.js";
@@ -362,7 +363,7 @@ async function withRedisFallback<T>(operation: () => Promise<T>): Promise<T | un
 
 export function createProviderCache(options: ProviderCacheOptions): ProviderCache {
 	const redisUrl = options.redisUrl ?? providerCacheRedisUrlFromEnv();
-	const configuredPepper = process.env[APIFUSE__CACHE__KEY_PEPPER_ENV];
+	const configuredPepper = readDiagnosticEnv(APIFUSE__CACHE__KEY_PEPPER_ENV);
 	const pepper = configuredPepper && configuredPepper.length > 0 ? configuredPepper : undefined;
 	const backend = getSharedBackend(redisUrl);
 	const memoryMaxEntries = Math.max(1, options.memoryMaxEntries ?? DEFAULT_MEMORY_MAX_ENTRIES);
@@ -599,7 +600,7 @@ export function isProviderCacheBypassed(cache: ProviderCache): boolean {
 export function createBypassProviderCache(
 	options: Pick<ProviderCacheOptions, "providerId">,
 ): ProviderCache {
-	const configuredPepper = process.env[APIFUSE__CACHE__KEY_PEPPER_ENV];
+	const configuredPepper = readDiagnosticEnv(APIFUSE__CACHE__KEY_PEPPER_ENV);
 	const pepper = configuredPepper && configuredPepper.length > 0 ? configuredPepper : undefined;
 	const events: ProviderCacheLookupMeta[] = [];
 	const secretScopedKeys = new Set<string>();

package/src/runtime/diagnostic-env-values.ts

@@ -0,0 +1,56 @@
+export function resolvedStringVariants(value: string | undefined): string[] {
+	if (value === undefined) return [];
+	return [...new Set([value, value.trim()])].filter((candidate) => candidate.length > 0);
+}
+
+function decodedComponent(value: string): string {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+export function urlCredentialComponents(
+	value: string,
+	options: { includePathAndQuery: boolean },
+): string[] {
+	let url: URL;
+	try {
+		url = new URL(value.trim());
+	} catch {
+		return [];
+	}
+	const username = decodedComponent(url.username);
+	const password = decodedComponent(url.password);
+	const components = [username, password, username && password ? `${username}:${password}` : ""];
+	if (options.includePathAndQuery) {
+		for (const segment of url.pathname.split("/")) {
+			if (segment) components.push(decodedComponent(segment));
+		}
+		for (const [key, entryValue] of url.searchParams) {
+			if (key) components.push(key);
+			if (entryValue) {
+				components.push(entryValue, `${key}=${entryValue}`);
+			}
+		}
+	}
+	return [...new Set(components.flatMap((component) => resolvedStringVariants(component)))];
+}
+
+export function otlpHeaderCredentialValues(value: string): string[] {
+	const variants = resolvedStringVariants(value);
+	for (const member of value.split(",")) {
+		const separator = member.indexOf("=");
+		if (separator <= 0) continue;
+		const headerValue = decodedComponent(member.slice(separator + 1).trim());
+		variants.push(...resolvedStringVariants(headerValue));
+		const headerName = decodedComponent(member.slice(0, separator).trim()).toLowerCase();
+		if (headerName === "authorization" || headerName === "proxy-authorization") {
+			// A transport may echo just the credential without its HTTP auth scheme.
+			const credential = /^(?:Bearer|Basic)\s+(.+)$/i.exec(headerValue)?.[1];
+			if (credential) variants.push(...resolvedStringVariants(credential));
+		}
+	}
+	return [...new Set(variants)];
+}

package/src/runtime/diagnostic-env.ts

@@ -0,0 +1,55 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+import {
+	resolvedStringVariants,
+	urlCredentialComponents,
+	otlpHeaderCredentialValues,
+} from "./diagnostic-env-values.js";
+import {
+	type CompiledDiagnosticSensitiveValues,
+	registerProcessDiagnosticValues,
+	suppressProcessDiagnosticValues,
+	withAppDiagnosticFallback,
+} from "./diagnostic-redactor.js";
+
+type EnvObserver = (name: string, value: string) => void;
+export interface DiagnosticEnvScope {
+	observe: EnvObserver;
+	finished: boolean;
+	staticValues?: CompiledDiagnosticSensitiveValues;
+}
+const observers = new AsyncLocalStorage<DiagnosticEnvScope>();
+
+/** Resolve and register atomically, before any consumer can use a live env credential. */
+export function readDiagnosticEnv(
+	name: string,
+	env: Readonly<Record<string, string | undefined>> = process.env,
+): string | undefined {
+	const value = env[name];
+	if (value !== undefined) {
+		const scope = observers.getStore();
+		if (scope && !scope.finished) scope.observe(name, value);
+		else {
+			// ALS survives the response. Finished requests register into the app's
+			// inherited fallback lifetime, never a dead request's private inventory.
+			if (Buffer.byteLength(value) > 64 * 1024) suppressProcessDiagnosticValues();
+			else
+				registerProcessDiagnosticValues([
+					...resolvedStringVariants(value),
+					...urlCredentialComponents(value, {
+						includePathAndQuery: name === "APIFUSE__CDP_POOL__URL",
+					}),
+					...(name === "OTEL_EXPORTER_OTLP_HEADERS" || name === "OTEL_EXPORTER_OTLP_TRACES_HEADERS"
+						? otlpHeaderCredentialValues(value)
+						: []),
+				]);
+		}
+	}
+	return value;
+}
+
+export function withDiagnosticEnv<T>(observer: EnvObserver | DiagnosticEnvScope, fn: () => T): T {
+	const scope = typeof observer === "function" ? { observe: observer, finished: false } : observer;
+	const run = () => observers.run(scope, fn);
+	return scope.staticValues ? withAppDiagnosticFallback(scope.staticValues, run) : run();
+}