@apifuse/provider-sdk 2.1.0-beta.9 → 2.2.0-beta.1

package/dist/runtime/browser.js

@@ -3,6 +3,106 @@ import { ProviderError } from "../errors";
 const require = createRequire(import.meta.url);
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
 const SELECTOR_POLL_INTERVAL_MS = 100;
+const RESOURCE_POLICY_ROUTE_PATTERN = "**/*";
+const DEFAULT_RESOURCE_METHODS = ["GET", "HEAD"];
+function toResourceBody(body) {
+    if (body === undefined || typeof body === "string" || Buffer.isBuffer(body)) {
+        return body;
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(body));
+    }
+    return Buffer.from(body);
+}
+function isResourceMethod(method) {
+    return method === "GET" || method === "HEAD";
+}
+async function toResourceRequest(request) {
+    const method = request.method().toUpperCase();
+    if (!isResourceMethod(method)) {
+        return null;
+    }
+    return {
+        headers: await request.allHeaders(),
+        method,
+        resourceType: request.resourceType(),
+        url: request.url(),
+    };
+}
+function toCdpResourceRequest(params) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    const requestId = params.requestId;
+    const rawRequest = params.request;
+    if (typeof requestId !== "string" || !isRecord(rawRequest)) {
+        return null;
+    }
+    const url = rawRequest.url;
+    const method = String(rawRequest.method ?? "").toUpperCase();
+    if (typeof url !== "string" || !isResourceMethod(method)) {
+        return null;
+    }
+    return {
+        requestId,
+        request: {
+            headers: toCdpResourceHeaders(rawRequest.headers),
+            method,
+            resourceType: typeof params.resourceType === "string" ? params.resourceType : undefined,
+            url,
+        },
+    };
+}
+function getCdpPausedRequestId(params) {
+    if (!isRecord(params) || typeof params.requestId !== "string") {
+        return null;
+    }
+    return params.requestId;
+}
+function toCdpResourceHeaders(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const headers = {};
+    for (const [name, headerValue] of Object.entries(value)) {
+        if (typeof headerValue === "string") {
+            headers[name] = headerValue;
+        }
+    }
+    return headers;
+}
+function matchesResourceRoute(match, request) {
+    if (typeof match === "string") {
+        return request.url === match;
+    }
+    if (match instanceof RegExp) {
+        return match.test(request.url);
+    }
+    return match(request);
+}
+function toCdpFulfillParams(requestId, decision) {
+    const body = toResourceBody(decision.body);
+    return {
+        ...(body === undefined
+            ? {}
+            : { body: Buffer.from(body).toString("base64") }),
+        ...(decision.headers === undefined
+            ? {}
+            : {
+                responseHeaders: Object.entries(decision.headers).map(([name, value]) => ({ name, value })),
+            }),
+        requestId,
+        responseCode: decision.status ?? 200,
+    };
+}
+async function fulfillResourceRoute(route, decision) {
+    const body = toResourceBody(decision.body);
+    await route.fulfill({
+        ...(body === undefined ? {} : { body }),
+        ...(decision.headers === undefined ? {} : { headers: decision.headers }),
+        status: decision.status ?? 200,
+    });
+}
 function getDefaultCdpPoolUrl(env = process.env) {
     return env.APIFUSE__CDP_POOL__URL;
 }
@@ -256,6 +356,38 @@ class PlaywrightBrowserPage {
     async close() {
         await this.page.close();
     }
+    async withResourcePolicy(policy, run) {
+        const allowedMethods = new Set(policy.allowedMethods ?? DEFAULT_RESOURCE_METHODS);
+        const handler = async (route) => {
+            const request = await toResourceRequest(route.request());
+            if (!request || !allowedMethods.has(request.method)) {
+                await route.abort("blockedbyclient");
+                return;
+            }
+            for (const resourceRoute of policy.routes) {
+                if (!matchesResourceRoute(resourceRoute.match, request)) {
+                    continue;
+                }
+                const decision = await resourceRoute.handle(request);
+                switch (decision.action) {
+                    case "fulfill":
+                        await fulfillResourceRoute(route, decision);
+                        return;
+                    case "block":
+                        await route.abort("blockedbyclient");
+                        return;
+                }
+            }
+            await route.abort("blockedbyclient");
+        };
+        await this.page.route(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+        try {
+            return await run();
+        }
+        finally {
+            await this.page.unroute(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+        }
+    }
 }
 class PlaywrightBrowserClient {
     options;
@@ -737,6 +869,77 @@ class CdpPoolBrowserPage {
             await this.pageClient.close();
         }
     }
+    async withResourcePolicy(policy, run) {
+        const allowedMethods = new Set(policy.allowedMethods ?? DEFAULT_RESOURCE_METHODS);
+        const handlePausedRequest = (params) => {
+            void this.handleResourcePolicyPausedRequest(params, policy, allowedMethods);
+        };
+        const unsubscribe = this.pageClient.on("Fetch.requestPaused", handlePausedRequest);
+        try {
+            await this.pageClient.send("Fetch.enable", {
+                patterns: [{ requestStage: "Request", urlPattern: "*" }],
+            });
+        }
+        catch (error) {
+            unsubscribe();
+            throw new ProviderError("CDP browser target does not support BrowserPage.withResourcePolicy()", {
+                cause: error instanceof Error ? error : undefined,
+                code: "BROWSER_RUNTIME_UNSUPPORTED",
+                fix: "Use a Chromium CDP target with the Fetch domain enabled, or use the local Playwright browser runtime.",
+            });
+        }
+        try {
+            return await run();
+        }
+        finally {
+            unsubscribe();
+            await this.pageClient.send("Fetch.disable");
+        }
+    }
+    async handleResourcePolicyPausedRequest(params, policy, allowedMethods) {
+        const requestId = getCdpPausedRequestId(params);
+        if (requestId === null) {
+            return;
+        }
+        try {
+            const parsed = toCdpResourceRequest(params);
+            if (!parsed || !allowedMethods.has(parsed.request.method)) {
+                await this.failCdpResourceRequest(requestId);
+                return;
+            }
+            for (const resourceRoute of policy.routes) {
+                if (!matchesResourceRoute(resourceRoute.match, parsed.request)) {
+                    continue;
+                }
+                const decision = await resourceRoute.handle(parsed.request);
+                switch (decision.action) {
+                    case "fulfill":
+                        await this.pageClient.send("Fetch.fulfillRequest", toCdpFulfillParams(parsed.requestId, decision));
+                        return;
+                    case "block":
+                        await this.failCdpResourceRequest(parsed.requestId);
+                        return;
+                }
+            }
+            await this.failCdpResourceRequest(parsed.requestId);
+        }
+        catch {
+            await this.failCdpResourceRequest(requestId);
+        }
+    }
+    async failCdpResourceRequest(requestId) {
+        try {
+            await this.pageClient.send("Fetch.failRequest", {
+                errorReason: "BlockedByClient",
+                requestId,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return;
+            }
+        }
+    }
     async initialize() {
         if (this.initialized) {
             return;

package/dist/runtime/http.js

@@ -396,7 +396,8 @@ function toHttpTransportError(error) {
 }
 async function toNativeHttpResponse(response) {
     const headers = Object.fromEntries(response.headers.entries());
-    const rawText = await response.text();
+    const bodyBytes = new Uint8Array(await response.arrayBuffer());
+    const rawText = new TextDecoder().decode(bodyBytes);
     const data = parseHttpData(rawText, headers);
     return {
         data,
@@ -412,6 +413,8 @@ async function toNativeHttpResponse(response) {
         ok: response.status >= 200 && response.status < 300,
         status: response.status,
         text: async () => rawText,
+        arrayBuffer: async () => bodyBytes.buffer.slice(bodyBytes.byteOffset, bodyBytes.byteOffset + bodyBytes.byteLength),
+        bytes: async () => bodyBytes.slice(0),
     };
 }
 async function drainNativeResponseBody(response) {
@@ -474,12 +477,18 @@ function isAbsoluteUrl(url) {
 function resolveHttpUrl(baseUrl, url) {
     return new URL(url, baseUrl ?? DEFAULT_HTTP_BASE_URL).toString();
 }
-async function resolveNativeProxy(options, clientOptions, warn) {
+async function resolveNativeProxy(options, clientOptions, warn, proxyAttemptOffset = 0) {
+    const baseProxyAttempt = clientOptions.proxyAttempt === undefined ||
+        !Number.isFinite(clientOptions.proxyAttempt)
+        ? 0
+        : Math.max(0, Math.floor(clientOptions.proxyAttempt));
     const resolvedProxy = await resolveProxyConfigAsync({
         proxy: options.proxy ?? clientOptions.proxy,
         upstream: clientOptions.upstream,
         apifuseConfig: clientOptions.apifuseConfig,
+        proxyPolicy: clientOptions.proxyPolicy,
         affinityKey: clientOptions.affinityKey,
+        proxyAttempt: baseProxyAttempt + proxyAttemptOffset,
         telemetry: clientOptions.telemetry,
     });
     if (resolvedProxy.shouldWarn) {
@@ -501,14 +510,15 @@ function normalizeNativeFetchBody(body) {
     copied.set(normalized);
     return copied.buffer;
 }
-async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, warn, statusRetryCodes) {
+async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, warn, statusRetryCodes, proxyAttemptOffset = 0) {
     const requestUrl = appendQueryParams(resolveHttpUrl(baseUrl, url), options.params);
     const controller = options.timeout ? new AbortController() : undefined;
     const timeoutHandle = options.timeout
         ? setTimeout(() => controller?.abort(), options.timeout)
         : undefined;
+    let proxy;
     try {
-        const proxy = await resolveNativeProxy(options, clientOptions, warn);
+        proxy = await resolveNativeProxy(options, clientOptions, warn, proxyAttemptOffset);
         const requestInit = {
             headers: options.headers,
             method,
@@ -529,6 +539,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
                 status: response.status,
                 headers,
                 retryable: statusRetryCodes.includes(response.status),
+                proxyUsed: Boolean(proxy),
             };
         }
         if (response.status >= 400 && options.throwOnHttpError !== false) {
@@ -544,7 +555,9 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
         if (error instanceof SyntaxError) {
             throw error;
         }
-        throw toHttpTransportError(error);
+        const transportError = toHttpTransportError(error);
+        transportError.proxyUsed = Boolean(proxy);
+        throw transportError;
     }
     finally {
         if (timeoutHandle)
@@ -608,20 +621,25 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
         assertNoHttpTransportOverrides(options);
         const headersOptions = withClientHeaders(options, clientOptions, options.body);
         const methodName = normalizeHttpMethod(method);
-        const retryOptions = normalizeRetryOptions(headersOptions.retry);
+        const explicitRetry = headersOptions.retry !== undefined;
+        const retryOptions = normalizeRetryOptions(headersOptions.retry) ??
+            (explicitRetry
+                ? undefined
+                : createRetryOptions(HttpRetryPreset.TransportTransient));
         if (retryOptions)
             validateUnsafeRetryMethods(retryOptions);
         const retryEnabled = Boolean(retryOptions &&
             retryOptions.attempts > 1 &&
             isMethodRetryable(methodName, retryOptions));
         const statusRetryEnabled = Boolean(retryEnabled &&
+            explicitRetry &&
             retryOptions &&
             retryOptions.statusCodes.length > 0 &&
             headersOptions.throwOnHttpError !== false);
         const attemptOptions = statusRetryEnabled
             ? { ...headersOptions, throwOnHttpError: false }
             : headersOptions;
-        const executeOnce = () => fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined);
+        const executeOnce = (proxyAttemptOffset = 0) => fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined, proxyAttemptOffset);
         if (!retryEnabled || !retryOptions) {
             const outcome = await executeOnce();
             if (isHttpStatusOutcome(outcome)) {
@@ -633,7 +651,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
         let lastStatus;
         for (let attempt = 1; attempt <= retryOptions.attempts; attempt += 1) {
             try {
-                const outcome = await executeOnce();
+                const outcome = await executeOnce(attempt - 1);
                 if (isHttpStatusOutcome(outcome)) {
                     lastStatus = outcome.status;
                     if (outcome.retryable && attempt < retryOptions.attempts) {
@@ -663,7 +681,9 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
             catch (error) {
                 lastErrorCode = retryErrorCode(error);
                 lastStatus = retryErrorStatus(error);
+                const proxyUsed = Boolean(error.proxyUsed);
                 if (attempt < retryOptions.attempts &&
+                    (explicitRetry || proxyUsed) &&
                     shouldRetryTransportError(error, retryOptions)) {
                     await sleep(computeRetryDelayMs(retryOptions, attempt));
                     continue;

package/dist/runtime/stealth.d.ts

@@ -12,7 +12,10 @@ export type StealthClientOptions = ProxyResolutionOptions & {
         insecureSkipVerify?: boolean;
     };
 };
-type StealthTransportResponse = Pick<ImpitResponse, "arrayBuffer" | "headers" | "json" | "ok" | "status" | "text" | "url">;
-export declare function normalizeResponse(response: StealthTransportResponse): Promise<StealthResponse>;
+type StealthTransportResponse = Pick<ImpitResponse, "arrayBuffer" | "headers" | "json" | "ok" | "status" | "text"> & {
+    url?: string;
+    redirected?: boolean;
+};
+export declare function normalizeResponse(response: StealthTransportResponse, requestUrl?: string): Promise<StealthResponse>;
 export declare function createStealthClient(baseUrl: string, defaultProfileOrOptions?: string | StealthClientOptions, clientOptions?: StealthClientOptions): StealthClient;
 export {};

package/dist/runtime/stealth.js

@@ -102,11 +102,32 @@ class CookieJarImpl {
     getAll() {
         return { ...this.cookies };
     }
+    has(name) {
+        return Object.hasOwn(this.cookies, name);
+    }
     toString() {
         return Object.entries(this.cookies)
             .map(([name, value]) => `${name}=${value}`)
             .join("; ");
     }
+    toHeader() {
+        return this.toString();
+    }
+    snapshot() {
+        return this.getAll();
+    }
+    restore(cookies) {
+        this.clear();
+        for (const [name, value] of Object.entries(cookies)) {
+            if (name)
+                this.cookies[name] = value;
+        }
+    }
+    clear() {
+        for (const name of Object.keys(this.cookies)) {
+            delete this.cookies[name];
+        }
+    }
     find(predicate) {
         for (const [name, value] of Object.entries(this.cookies)) {
             const cookie = `${name}=${value}`;
@@ -237,7 +258,7 @@ function splitCombinedSetCookieHeader(headerValue) {
         cookieStrings.push(finalCookie);
     return cookieStrings;
 }
-export async function normalizeResponse(response) {
+export async function normalizeResponse(response, requestUrl) {
     const headers = Object.fromEntries(response.headers.entries());
     const cookies = new CookieJarImpl(setCookieHeadersFromResponse(response.headers));
     const bodyBytes = await response.arrayBuffer();
@@ -245,6 +266,12 @@ export async function normalizeResponse(response) {
     return {
         status: response.status,
         ok: response.status >= 200 && response.status < 300,
+        ...(response.url ? { url: response.url } : {}),
+        ...(response.redirected !== undefined
+            ? { redirected: response.redirected }
+            : requestUrl && response.url
+                ? { redirected: response.url !== requestUrl }
+                : {}),
         headers,
         rawHeaders: headerEntriesFromHeaders(response.headers),
         body,
@@ -537,6 +564,23 @@ function normalizeMethod(method) {
             throw new SDKError(`Unsupported stealth method: ${method}`);
     }
 }
+function isRedirectStatus(status) {
+    return [301, 302, 303, 307, 308].includes(status);
+}
+function nextRedirectMethod(status, method) {
+    if (status === 303 && method !== "HEAD")
+        return "GET";
+    if ((status === 301 || status === 302) && method === "POST")
+        return "GET";
+    return method;
+}
+function locationHeader(headers) {
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === "location")
+            return value;
+    }
+    return undefined;
+}
 function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
     const clients = new Map();
     let closed = false;
@@ -588,7 +632,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
             proxyHash: proxyEndpointHash(resolvedProxy.url),
         };
     }
-    return {
+    const session = {
         async fetch(url, options = {}) {
             const method = normalizeMethod(options.method ?? "GET");
             const hasExplicitRetryPolicy = options.retry !== undefined;
@@ -656,13 +700,14 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                         const requestInit = {
                             headers: normalizeHeaders(headers),
                             method,
+                            ...(options.redirect ? { redirect: options.redirect } : {}),
                             ...(options.timeout ? { timeout: options.timeout } : {}),
                         };
                         if (options.body !== undefined) {
                             requestInit.body = normalizeBody(options.body);
                         }
                         const response = await getClient(profileName, proxy, ignoreTlsErrors).fetch(requestUrl, requestInit);
-                        const normalized = await normalizeResponse(response);
+                        const normalized = await normalizeResponse(response, requestUrl);
                         cookieJar.setFromCookieStrings(setCookieHeadersFromResponse(response.headers));
                         if (proxy &&
                             isProxyConnectFailureResponse(response, normalized.body)) {
@@ -758,11 +803,112 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
             }
             throw normalizeStealthTransportError(lastError);
         },
+        cookies: cookieJar,
+        redirects: {
+            async run(options) {
+                const maxHops = options.maxHops === undefined || !Number.isFinite(options.maxHops)
+                    ? 10
+                    : Math.max(0, Math.floor(options.maxHops));
+                const hops = [];
+                let currentUrl = resolveUrl(baseUrl, options.url);
+                let method = normalizeMethod(options.method ?? "GET");
+                let body = options.body;
+                let response;
+                const visitedRequests = new Set();
+                const { url: _url, maxHops: _maxHops, stopWhen, params, ...fetchOptions } = options;
+                for (let hopIndex = 0; hopIndex <= maxHops; hopIndex += 1) {
+                    visitedRequests.add(`${method} ${currentUrl}`);
+                    response = await session.fetch(currentUrl, {
+                        ...fetchOptions,
+                        body,
+                        method,
+                        ...(hopIndex === 0 && params ? { params } : {}),
+                        redirect: "manual",
+                        throwOnHttpError: false,
+                    });
+                    if (!isRedirectStatus(response.status)) {
+                        return {
+                            final: response,
+                            hops,
+                            reason: "completed",
+                            cookies: cookieJar.snapshot(),
+                        };
+                    }
+                    const location = locationHeader(response.headers);
+                    const nextUrl = location
+                        ? new URL(location, response.url ?? currentUrl).toString()
+                        : undefined;
+                    const hop = {
+                        url: response.url ?? currentUrl,
+                        status: response.status,
+                        method,
+                        ...(location ? { location } : {}),
+                        ...(nextUrl ? { nextUrl } : {}),
+                    };
+                    hops.push(hop);
+                    if (stopWhen && (await stopWhen(hop))) {
+                        return {
+                            final: response,
+                            hops,
+                            reason: "stopped",
+                            cookies: cookieJar.snapshot(),
+                        };
+                    }
+                    if (!nextUrl) {
+                        return {
+                            final: response,
+                            hops,
+                            reason: "missing_location",
+                            cookies: cookieJar.snapshot(),
+                        };
+                    }
+                    if (hops.length > maxHops) {
+                        return {
+                            final: response,
+                            hops,
+                            reason: "max_hops",
+                            cookies: cookieJar.snapshot(),
+                        };
+                    }
+                    const nextMethod = nextRedirectMethod(response.status, method);
+                    if (nextMethod !== method) {
+                        body = undefined;
+                    }
+                    if (visitedRequests.has(`${nextMethod} ${nextUrl}`)) {
+                        return {
+                            final: response,
+                            hops,
+                            reason: "loop",
+                            cookies: cookieJar.snapshot(),
+                        };
+                    }
+                    method = nextMethod;
+                    currentUrl = nextUrl;
+                }
+                if (!response) {
+                    response = await session.fetch(currentUrl, {
+                        ...fetchOptions,
+                        body,
+                        method,
+                        ...(params ? { params } : {}),
+                        redirect: "manual",
+                        throwOnHttpError: false,
+                    });
+                }
+                return {
+                    final: response,
+                    hops,
+                    reason: "max_hops",
+                    cookies: cookieJar.snapshot(),
+                };
+            },
+        },
         close() {
             closed = true;
             clients.clear();
         },
     };
+    return session;
     async function classifyProxyAuthDiagnostic(profileName, proxy) {
         try {
             const response = await getClient(profileName, proxy, false).fetch(PROXY_AUTH_DIAGNOSTIC_URL, {

package/dist/server/index.d.ts

@@ -1,3 +1,7 @@
 export { createServerApp, type ServeOptions, serve } from "./serve";
+export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, type SelfTestAppOptions, type SelfTestCaseResult, type SelfTestCaseStatus, type SelfTestOperationInvoke, type SelfTestRequest, SelfTestRequestSchema, type SelfTestResponse, } from "./self-test";
+export { resolveHealthCheckInputDateTokens } from "./self-test-input-tokens";
+export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction";
+export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, type SelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token";
 export type { AuthFlowRequest, AuthFlowResponse, AuthFlowSuccessResponse, ConnectionMode, OperationConnection, OperationErrorResponse, OperationRequest, OperationResponse, OperationSuccessResponse, } from "./types";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types";

package/dist/server/index.js

@@ -1,2 +1,6 @@
 export { createServerApp, serve } from "./serve";
+export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, SelfTestRequestSchema, } from "./self-test";
+export { resolveHealthCheckInputDateTokens } from "./self-test-input-tokens";
+export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction";
+export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types";

package/dist/server/self-test-input-tokens.d.ts

@@ -0,0 +1 @@
+export declare function resolveHealthCheckInputDateTokens(value: unknown, now?: Date): unknown;

package/dist/server/self-test-input-tokens.js

@@ -0,0 +1,37 @@
+/**
+ * Relative-KST date token resolution for health-check case inputs, ported from
+ * the monorepo health-monitor (`apps/health-monitor/src/lib/health-check-input.ts`)
+ * so provider self-tests resolve durable probe inputs identically.
+ *
+ * Supported token: `+<days>d` or `+<days>d:YYYYMMDD` (1..365 days ahead, KST).
+ */
+const RELATIVE_KST_DATE_TOKEN = /^\+(\d{1,3})d(?::(YYYYMMDD))?$/i;
+function dateFromKstDaysAhead(daysAhead, now = new Date(), format = "YYYY-MM-DD") {
+    const kstNow = new Date(now.getTime() + 9 * 60 * 60 * 1000);
+    const date = new Date(Date.UTC(kstNow.getUTCFullYear(), kstNow.getUTCMonth(), kstNow.getUTCDate() + daysAhead));
+    const isoDate = date.toISOString().slice(0, 10);
+    return format === "YYYYMMDD" ? isoDate.replace(/-/g, "") : isoDate;
+}
+export function resolveHealthCheckInputDateTokens(value, now = new Date()) {
+    if (typeof value === "string") {
+        const relative = value.match(RELATIVE_KST_DATE_TOKEN);
+        if (!relative)
+            return value;
+        const daysAhead = Number(relative[1]);
+        if (!Number.isInteger(daysAhead) || daysAhead < 1 || daysAhead > 365) {
+            return value;
+        }
+        const format = relative[2]?.toUpperCase() === "YYYYMMDD" ? "YYYYMMDD" : "YYYY-MM-DD";
+        return dateFromKstDaysAhead(daysAhead, now, format);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => resolveHealthCheckInputDateTokens(entry, now));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            resolveHealthCheckInputDateTokens(entry, now),
+        ]));
+    }
+    return value;
+}

package/dist/server/self-test-redaction.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderDefinition } from "../types";
+export declare const SELF_TEST_REDACTED_PLACEHOLDER = "[REDACTED]";
+/** Maximum length of any string echoed in a self-test response. */
+export declare const SELF_TEST_MAX_TEXT_LENGTH = 300;
+/**
+ * Collects every secret-shaped value known to the self-test runtime so probe
+ * results can be scrubbed before they leave the pod: master secrets, declared
+ * provider env secrets, health-probe credential env values, and request-supplied
+ * credential inputs.
+ */
+export declare function collectSelfTestSensitiveValues(provider: ProviderDefinition, options?: {
+    env?: Readonly<Record<string, string | undefined>>;
+    credentialInputs?: Readonly<Record<string, string>>;
+}): string[];
+/**
+ * Scrubs known secret values and header-shaped credentials from a string and
+ * caps its length. Every string embedded in a SelfTestResponse MUST pass
+ * through this before serialization.
+ */
+export declare function redactSelfTestText(text: string, sensitiveValues: readonly string[], maxLength?: number): string;