zitejs 0.10.0-start.12 → 0.10.0-start.13

package/dist/esm/start/aiUsage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What a call on an org's own AI key used, read from the provider's answer as
+ * classic's runtime reads it. For analytics only: the org pays the provider.
+ * OpenAI and Anthropic; the host meters Zite's own key itself.
+ */
+export type AiProvider = "openai" | "anthropic";
+export type AiUsageRecord = {
+    provider: AiProvider;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    isStreaming?: true;
+};
+export declare const AI_USAGE_HOSTS: Record<string, AiProvider>;
+/** As classic: an OpenAI chat stream reports its usage only when asked to. The body to send instead, if any. */
+export declare const withStreamUsage: (url: URL, method: string, body: unknown) => string | undefined;
+/** The response to hand the app, and its usage once read; a stream is split so the app reads one copy as it arrives. */
+export declare const meterAiResponse: (provider: AiProvider, response: Response) => {
+    response: Response;
+    usage: Promise<AiUsageRecord | undefined>;
+};

package/dist/esm/start/aiUsage.js

@@ -0,0 +1,146 @@
+/**
+ * What a call on an org's own AI key used, read from the provider's answer as
+ * classic's runtime reads it. For analytics only: the org pays the provider.
+ * OpenAI and Anthropic; the host meters Zite's own key itself.
+ */
+export const AI_USAGE_HOSTS = {
+    "api.openai.com": "openai",
+    "api.anthropic.com": "anthropic",
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/** As classic: an OpenAI chat stream reports its usage only when asked to. The body to send instead, if any. */
+export const withStreamUsage = (url, method, body) => {
+    if (method !== "POST" || typeof body !== "string" || !url.pathname.endsWith("/chat/completions"))
+        return undefined;
+    try {
+        const json = JSON.parse(body);
+        if (!isRecord(json) || json.stream !== true)
+            return undefined;
+        const options = isRecord(json.stream_options) ? json.stream_options : {};
+        if (options.include_usage === true)
+            return undefined;
+        return JSON.stringify({ ...json, stream_options: { ...options, include_usage: true } });
+    }
+    catch {
+        return undefined;
+    }
+};
+// OpenAI counts cached tokens inside its input; classic takes them apart.
+const tokensFromJson = (provider, body) => {
+    const tokens = {};
+    if (!isRecord(body))
+        return tokens;
+    if (provider === "openai") {
+        const source = isRecord(body.response) ? body.response : body;
+        if (typeof source.model === "string")
+            tokens.model = source.model;
+        const usage = isRecord(source.usage) ? source.usage : undefined;
+        if (!usage)
+            return tokens;
+        const details = (name) => (isRecord(usage[name]) ? usage[name] : {});
+        const cached = details("prompt_tokens_details").cached_tokens ?? details("input_tokens_details").cached_tokens;
+        const input = usage.prompt_tokens ?? usage.input_tokens;
+        const output = usage.completion_tokens ?? usage.output_tokens;
+        if (isNumber(input))
+            tokens.inputTokens = input - (isNumber(cached) ? cached : 0);
+        if (isNumber(output))
+            tokens.outputTokens = output;
+        if (isNumber(cached))
+            tokens.cachedReadInputTokens = cached;
+        return tokens;
+    }
+    // A stream splits these: message_start has the input, message_delta the running output.
+    const message = isRecord(body.message) ? body.message : body;
+    if (typeof message.model === "string")
+        tokens.model = message.model;
+    const usage = isRecord(message.usage) ? message.usage : isRecord(body.usage) ? body.usage : undefined;
+    if (!usage)
+        return tokens;
+    if (isNumber(usage.input_tokens))
+        tokens.inputTokens = usage.input_tokens;
+    if (isNumber(usage.output_tokens))
+        tokens.outputTokens = usage.output_tokens;
+    if (isNumber(usage.cache_read_input_tokens))
+        tokens.cachedReadInputTokens = usage.cache_read_input_tokens;
+    if (isNumber(usage.cache_creation_input_tokens))
+        tokens.cacheCreationInputTokens = usage.cache_creation_input_tokens;
+    return tokens;
+};
+// Later readings win: Anthropic's output is cumulative, OpenAI's usage comes last.
+const merge = (into, next) => ({
+    model: next.model ?? into.model,
+    inputTokens: next.inputTokens ?? into.inputTokens,
+    outputTokens: next.outputTokens ?? into.outputTokens,
+    cachedReadInputTokens: next.cachedReadInputTokens ?? into.cachedReadInputTokens,
+    cacheCreationInputTokens: next.cacheCreationInputTokens ?? into.cacheCreationInputTokens,
+});
+const MAX_PENDING_LINE = 1024 * 1024;
+const tokensFromStream = async (provider, stream) => {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    let tokens = {};
+    const readLine = (line) => {
+        if (!line.startsWith("data:"))
+            return;
+        const payload = line.slice(5).trim();
+        if (!payload || payload === "[DONE]")
+            return;
+        try {
+            tokens = merge(tokens, tokensFromJson(provider, JSON.parse(payload)));
+        }
+        catch {
+            // Not JSON; nothing to count.
+        }
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            pending += decoder.decode(value, { stream: true });
+            const lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            if (pending.length > MAX_PENDING_LINE)
+                pending = "";
+            lines.forEach(readLine);
+        }
+        readLine(pending);
+    }
+    catch {
+        // What was read before the stream broke still counts.
+    }
+    return tokens;
+};
+const counted = (tokens) => tokens.inputTokens !== undefined || tokens.outputTokens !== undefined;
+const usageOf = (provider, tokens, streaming) => counted(tokens)
+    ? {
+        provider,
+        ...Object.fromEntries(Object.entries(tokens).filter(([, value]) => value !== undefined)),
+        ...(streaming && { isStreaming: true }),
+    }
+    : undefined;
+/** The response to hand the app, and its usage once read; a stream is split so the app reads one copy as it arrives. */
+export const meterAiResponse = (provider, response) => {
+    const type = response.headers.get("content-type") ?? "";
+    if (!response.ok || !response.body)
+        return { response, usage: Promise.resolve(undefined) };
+    if (type.includes("text/event-stream")) {
+        const [forApp, forUs] = response.body.tee();
+        return {
+            response: new Response(forApp, response),
+            usage: tokensFromStream(provider, forUs).then((tokens) => usageOf(provider, tokens, true)),
+        };
+    }
+    if (!type.includes("json"))
+        return { response, usage: Promise.resolve(undefined) };
+    return {
+        response,
+        usage: response
+            .clone()
+            .json()
+            .then((json) => usageOf(provider, tokensFromJson(provider, json), false))
+            .catch(() => undefined),
+    };
+};

package/dist/esm/start/airtable/index.d.ts

@@ -2,10 +2,7 @@ import { type AirtableSettings } from "./dispatch.js";
 import type { PlatformSession, ZiteRequestContext } from "../types.js";
 /** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
 export declare const airtableSettingsOf: (session: PlatformSession, integrationId: string) => Promise<AirtableSettings | undefined>;
-/**
- * One generated Airtable table call, run here with the connection's placeholder
- * token; egress swaps the real one in for Airtable alone, and refreshes it.
- */
+/** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export declare function runAirtableCall(host: ZiteRequestContext, session: PlatformSession, integrationId: string, settings: AirtableSettings, methodName: string, params: unknown, access: "signedIn" | "anyone" | "webhook" | "workflow"): Promise<unknown>;
 /** For tests: forget what this isolate learned. */
 export declare const resetAirtableSettings: () => void;

package/dist/esm/start/airtable/index.js

@@ -1,8 +1,8 @@
 import { executeAirtableCall } from "./dispatch.js";
+import { INTEGRATIONS_PLATFORM_ID } from "../credentials.js";
 import { ZiteError, isZiteErrorCode } from "../errors.js";
+import { rememberConnection } from "../outbound.js";
 const AIRTABLE_API = "https://api.airtable.com";
-// The platform id `integrations.get` is answered under (`INTEGRATIONS_SDK_INTEGRATION_ID`).
-const CONNECTIONS = "__connections__";
 // A build's integrations don't change, so per isolate: only answers, never a pending call.
 const settingsHeld = new Map();
 let unsupported = false;
@@ -29,21 +29,20 @@ export const airtableSettingsOf = async (session, integrationId) => {
         throw error;
     }
 };
-/**
- * One generated Airtable table call, run here with the connection's placeholder
- * token; egress swaps the real one in for Airtable alone, and refreshes it.
- */
+/** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export async function runAirtableCall(host, session, integrationId, settings, methodName, params, access) {
     // As classic: a demo reaches no connected account.
     if (host.mode === "demo")
         throw new ZiteError("FORBIDDEN", "This action is not available in demo mode");
-    const connection = await session.call({
-        integrationId: CONNECTIONS,
-        className: "Connections",
-        methodName: "get",
-        params: { name: integrationId },
-        access,
-    });
+    const connection = host.credentials
+        ? await host.credentials.get(integrationId)
+        : await session.call({
+            integrationId: INTEGRATIONS_PLATFORM_ID,
+            className: "Connections",
+            methodName: "get",
+            params: { name: integrationId },
+            access,
+        });
     if ("error" in connection) {
         const { code, message, userFacingMessage } = connection.error;
         throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
@@ -52,6 +51,7 @@ export async function runAirtableCall(host, session, integrationId, settings, me
     if (typeof token !== "string") {
         throw new ZiteError("INTERNAL_ERROR", `The ${integrationId} connection has no token`);
     }
+    rememberConnection(host, integrationId, connection.value);
     host.airtableReads ??= new Map();
     return executeAirtableCall({
         settings,

package/dist/esm/start/credentials.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Where `integrations.get` reads a connection. In Zite's cloud the host
+ * answers it on the request's session; an app run elsewhere names its own
+ * source in its server entry: memory or the environment here, a shared cache
+ * once one exists.
+ */
+import type { PlatformCallInput, PlatformCallResult, PlatformSession } from "./types.js";
+export type CredentialSource = {
+    get(name: string): Promise<PlatformCallResult>;
+    /** After a provider answered 401: the connection refreshed, where the source can. */
+    refresh?(name: string): Promise<PlatformCallResult>;
+};
+export declare const INTEGRATIONS_PLATFORM_ID = "__connections__";
+/** The host's, on the request's session. */
+export declare const sessionCredentials: (session: PlatformSession, access: PlatformCallInput["access"]) => CredentialSource;
+/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
+export declare const memoryCredentials: (connections: Record<string, unknown>, refresh?: (name: string) => Promise<unknown>) => CredentialSource;
+/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
+export declare const envCredentials: (env?: Record<string, string | undefined>) => CredentialSource;

package/dist/esm/start/credentials.js

@@ -0,0 +1,30 @@
+/**
+ * Where `integrations.get` reads a connection. In Zite's cloud the host
+ * answers it on the request's session; an app run elsewhere names its own
+ * source in its server entry: memory or the environment here, a shared cache
+ * once one exists.
+ */
+export const INTEGRATIONS_PLATFORM_ID = "__connections__";
+/** The host's, on the request's session. */
+export const sessionCredentials = (session, access) => ({
+    get: (name) => session.call({ integrationId: INTEGRATIONS_PLATFORM_ID, className: "Connections", methodName: "get", params: { name }, access }),
+    ...(session.refreshConnection && { refresh: (name) => session.refreshConnection(name) }),
+});
+const notFound = (name) => ({
+    error: { code: "BAD_REQUEST", message: `Integration ${name} not found` },
+});
+/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
+export const memoryCredentials = (connections, refresh) => ({
+    get: async (name) => (Object.hasOwn(connections, name) ? { value: connections[name] } : notFound(name)),
+    ...(refresh && {
+        refresh: async (name) => {
+            const fresh = await refresh(name);
+            if (fresh === undefined)
+                return notFound(name);
+            connections[name] = fresh;
+            return { value: fresh };
+        },
+    }),
+});
+/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
+export const envCredentials = (env = process.env) => memoryCredentials(JSON.parse(env.ZITE_CONNECTIONS ?? "{}"));

package/dist/esm/start/outbound.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Every fetch an app makes on the server, wrapped as classic's runtime wraps
+ * it: logged, every secret it knows redacted, with the connection whose token
+ * it carries and what an org's own AI key used; a 401 on a connection's token
+ * refreshed and sent once more; and a call on Zite's own AI key sent to the
+ * host over the app's platform binding.
+ */
+import type { ZiteRequestContext } from "./types.js";
+/** An `integrations.get` answer, whose values name the calls that carry them. */
+export declare const rememberConnection: (host: ZiteRequestContext, name: string, connection: unknown) => void;
+export declare const createOutboundFetch: (nativeFetch: typeof fetch) => typeof fetch;

package/dist/esm/start/outbound.js

@@ -0,0 +1,417 @@
+/**
+ * Every fetch an app makes on the server, wrapped as classic's runtime wraps
+ * it: logged, every secret it knows redacted, with the connection whose token
+ * it carries and what an org's own AI key used; a 401 on a connection's token
+ * refreshed and sent once more; and a call on Zite's own AI key sent to the
+ * host over the app's platform binding.
+ */
+import { AI_USAGE_HOSTS, meterAiResponse, withStreamUsage } from "./aiUsage.js";
+import { sessionCredentials } from "./credentials.js";
+import { REDACTED, redactKnown, secretForms } from "./redactSecrets.js";
+import { getHost } from "./scope.js";
+const MAX_FETCHES = 500;
+// Shorter values (a region, a flag) aren't tokens, and could match by chance.
+const MIN_TOKEN_LENGTH = 8;
+// As classic: Workers send no User-Agent, and some APIs (GitHub) refuse a request without one.
+const DEFAULT_USER_AGENT = "zite";
+// The backend's stand-in for Zite's own AI key, which only the host answers.
+const AI_MARKER = /^zite_ai_gateway:[a-z]+:(.+)$/;
+// Where a provider SDK given the connection's `baseUrl` sends it; it never resolves.
+const AI_HOST = "zite-ai.invalid";
+// A provider's own base URL at the host: `/v1` is OpenAI's, Anthropic's SDK sends it in the path.
+const AI_PROVIDER_HOSTS = {
+    "api.openai.com": { provider: "openai", strip: "/v1" },
+    "api.anthropic.com": { provider: "anthropic", strip: "" },
+};
+// As classic's run log: a body up to 50 KB, a request's fetch bodies up to 200 KB in all.
+const MAX_BODY_CHARS = 50 * 1024;
+const MAX_LOGGED_CHARS = 200 * 1024;
+const MAX_URL_CHARS = 2_000;
+const MAX_ERROR_CHARS = 1_000;
+const SECRET_HEADER = /auth|key|token|secret|signature|password|cookie|session/i;
+// Usage still being read when the request's log is flushed isn't waited on for longer.
+const USAGE_WAIT_MS = 10_000;
+// Tokens refreshed in this isolate, which a later request's props may not name yet.
+const MAX_REFRESHED = 50;
+const refreshedTokens = new Map();
+const replacements = new Map();
+// Moves with each refresh, so a request's list of secrets takes in a token another one refreshed.
+let refreshes = 0;
+const remember = (map, key, value) => {
+    map.delete(key);
+    map.set(key, value);
+    if (map.size > MAX_REFRESHED)
+        map.delete(map.keys().next().value);
+};
+const tokensOf = (host) => {
+    if (host.connectionTokens)
+        return host.connectionTokens;
+    const tokens = new Map(refreshedTokens);
+    for (const [key, name] of Object.entries(host.envConnections ?? {})) {
+        const value = host.env?.[key];
+        if (value && value.length >= MIN_TOKEN_LENGTH)
+            tokens.set(value, name);
+    }
+    host.connectionTokens = tokens;
+    return tokens;
+};
+/** An `integrations.get` answer, whose values name the calls that carry them. */
+export const rememberConnection = (host, name, connection) => {
+    (host.connectionAnswers ??= new Map()).set(name, connection);
+    host.secretValues = undefined;
+    const tokens = tokensOf(host);
+    for (const [field, value] of Object.entries((connection ?? {}))) {
+        if (field !== "status" && field !== "baseUrl" && typeof value === "string" && value.length >= MIN_TOKEN_LENGTH) {
+            tokens.set(value, name);
+        }
+    }
+};
+const bare = (value) => value.replace(/^(?:Bearer|Token)\s+/i, "");
+const isUrl = (value) => /^https?:\/\//i.test(value);
+/** Every value this request knows is secret, longest first. */
+const secretsOf = (host) => {
+    if (host.secretValues && host.secretsAt === refreshes)
+        return host.secretValues;
+    const values = new Set([...refreshedTokens.keys(), ...replacements.values()]);
+    // A connection's own URL (an instance, an account) says which call failed; a user's secret may be a URL.
+    const add = (value, urls) => {
+        if (typeof value !== "string" || value.length < MIN_TOKEN_LENGTH || AI_MARKER.test(value))
+            return;
+        if (urls || !isUrl(value))
+            values.add(value);
+    };
+    for (const answer of host.connectionAnswers?.values() ?? []) {
+        for (const [field, value] of Object.entries((answer ?? {}))) {
+            if (field !== "status" && field !== "baseUrl")
+                add(value, false);
+        }
+    }
+    for (const [key, value] of Object.entries(host.env ?? {}))
+        add(value, !host.envConnections?.[key]);
+    host.secretValues = [...values].sort((a, b) => b.length - a.length);
+    host.secretsAt = refreshes;
+    return host.secretValues;
+};
+/** The values a request's own credential headers carry, which the log redacts too. */
+const headerSecrets = (headers) => [...headers].flatMap(([name, value]) => {
+    const secret = bare(value);
+    return SECRET_HEADER.test(name) && secret.length >= MIN_TOKEN_LENGTH && !AI_MARKER.test(secret) ? [secret] : [];
+});
+/** `text` cut to `max`, every secret in it redacted, none cut in half first, however it was written. */
+const loggable = (text, secrets, max) => {
+    const reach = secrets.reduce((longest, secret) => Math.max(longest, secretForms(secret)[0].length), 0);
+    return redactKnown(text.slice(0, max + reach), secrets).slice(0, max);
+};
+const decodings = (raw) => {
+    const decoded = [raw];
+    for (const text of [raw, raw.replace(/\+/g, " ")]) {
+        try {
+            decoded.push(decodeURIComponent(text));
+        }
+        catch {
+            // Not encoded as a whole; matched as written.
+        }
+    }
+    return decoded;
+};
+/** A URL with each path segment or query value that holds a secret, however it was encoded, redacted whole. */
+const redactedUrl = (url, secrets) => {
+    const holds = (raw) => decodings(raw).some((text) => secrets.some((secret) => text.includes(secret)));
+    const path = url.pathname
+        .split("/")
+        .map((segment) => (holds(segment) ? REDACTED : segment))
+        .join("/");
+    const query = url.search
+        ? `?${url.search
+            .slice(1)
+            .split("&")
+            .map((pair) => {
+            const at = pair.indexOf("=");
+            if (at < 0)
+                return holds(pair) ? REDACTED : pair;
+            return holds(pair.slice(at + 1)) ? `${pair.slice(0, at)}=${REDACTED}` : pair;
+        })
+            .join("&")}`
+        : "";
+    return `${url.protocol}//${url.host}${path}${query}`;
+};
+/** A request body as classic's run log shows it. */
+const bodyText = (body) => {
+    if (body === undefined || body === null)
+        return undefined;
+    if (typeof body === "string")
+        return body;
+    if (body instanceof URLSearchParams)
+        return body.toString();
+    if (body instanceof ReadableStream)
+        return "[stream]";
+    if (body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body))
+        return "[binary data]";
+    if (typeof FormData !== "undefined" && body instanceof FormData)
+        return "[binary data]";
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return "[non-serializable body]";
+    }
+};
+const settledWithin = (promise, ms) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    promise.then(() => {
+        clearTimeout(timer);
+        resolve();
+    }, () => {
+        clearTimeout(timer);
+        resolve();
+    });
+});
+/** The connection token a request carries, in a header or its query. */
+const carried = (headers, url, tokens) => {
+    for (const [, value] of headers) {
+        const connection = tokens.get(bare(value));
+        if (connection)
+            return { token: bare(value), connection };
+    }
+    for (const [, value] of url.searchParams) {
+        const connection = tokens.get(value);
+        if (connection)
+            return { token: value, connection };
+    }
+    return undefined;
+};
+/** `url` with each query value equal to `from` set to `to`, every other pair left as it was written. */
+const withQueryValue = (url, from, to) => {
+    if (!url.search)
+        return url;
+    const pairs = url.search
+        .slice(1)
+        .split("&")
+        .map((pair) => {
+        const at = pair.indexOf("=");
+        if (at < 0)
+            return pair;
+        let value;
+        try {
+            value = decodeURIComponent(pair.slice(at + 1).replace(/\+/g, " "));
+        }
+        catch {
+            return pair;
+        }
+        return value === from ? `${pair.slice(0, at)}=${encodeURIComponent(to)}` : pair;
+    });
+    const swapped = new URL(url);
+    swapped.search = `?${pairs.join("&")}`;
+    return swapped;
+};
+const swapHeaders = (headers, from, to) => {
+    for (const [name, value] of [...headers]) {
+        if (value.includes(from))
+            headers.set(name, value.split(from).join(to));
+    }
+};
+/** Where a call on Zite's AI key goes at the host, whether the app named the provider or the `baseUrl` it was given. */
+const aiTarget = (url, headers) => {
+    const marker = [...headers].map(([, value]) => AI_MARKER.exec(bare(value))).find(Boolean);
+    if (url.hostname === AI_HOST)
+        return { target: url, connection: marker?.[1] };
+    const route = AI_PROVIDER_HOSTS[url.hostname];
+    if (!route || !marker)
+        return undefined;
+    const path = url.pathname.startsWith(route.strip) ? url.pathname.slice(route.strip.length) : url.pathname;
+    return { target: new URL(`https://${AI_HOST}/${route.provider}${path}${url.search}`), connection: marker[1] };
+};
+const sessionOf = async (host) => {
+    if (!host.platform)
+        return undefined;
+    host.session ??= Promise.resolve(host.watch ? host.platform.session(host.watch) : host.platform.session());
+    return host.session;
+};
+const credentialsOf = async (host) => {
+    if (host.credentials)
+        return host.credentials;
+    const session = await sessionOf(host);
+    return session && sessionCredentials(session, "anyone");
+};
+/** The token to send instead of `token`, refreshed once per connection per request. */
+const freshToken = async (host, token, connection) => {
+    const known = replacements.get(token);
+    if (known)
+        return known;
+    const refreshing = (host.refreshing ??= new Map());
+    let pending = refreshing.get(connection);
+    if (!pending) {
+        pending = (async () => {
+            const source = await credentialsOf(host);
+            const result = source?.refresh ? await source.refresh(connection) : undefined;
+            if (!result || !("value" in result))
+                return undefined;
+            const fresh = result.value;
+            const previous = (host.connectionAnswers?.get(connection) ?? {});
+            const field = Object.keys(previous).find((key) => previous[key] === token) ?? "accessToken";
+            const value = fresh[field];
+            rememberConnection(host, connection, fresh);
+            return typeof value === "string" ? value : undefined;
+        })();
+        refreshing.set(connection, pending);
+    }
+    const value = await pending;
+    if (!value || value === token)
+        return undefined;
+    remember(replacements, token, value);
+    remember(refreshedTokens, value, connection);
+    refreshes += 1;
+    // As classic: the env vars that held the old token hold the new one.
+    const env = globalThis.process?.env;
+    for (const [key, held] of Object.entries(env ?? {})) {
+        if (held === token)
+            env[key] = value;
+    }
+    return value;
+};
+const hostOf = (input) => {
+    try {
+        return new URL(input instanceof Request ? input.url : input).host;
+    }
+    catch {
+        return "?";
+    }
+};
+const aiUnavailable = () => Response.json({ error: { type: "unavailable", message: "Zite's AI key works only in an app Zite hosts" } }, { status: 503 });
+const cfOf = (request) => request.cf;
+export const createOutboundFetch = (nativeFetch) => async (input, init) => {
+    const host = getHost();
+    if (!host)
+        return nativeFetch(input, init);
+    // A page that fetched depends on more than the reads the host saw, so the
+    // host must hear of it before the fetch goes out.
+    if (host.watch)
+        await host.watch.uncacheable(`fetch ${hostOf(input)}`);
+    let url;
+    try {
+        url = new URL(input instanceof Request ? input.url : input);
+    }
+    catch {
+        return nativeFetch(input, init);
+    }
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    if (!headers.has("user-agent"))
+        headers.set("user-agent", DEFAULT_USER_AGENT);
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const ai = aiTarget(url, headers);
+    const found = ai ? undefined : carried(headers, url, tokensOf(host));
+    const startedAt = Date.now();
+    const sentBody = bodyText(init?.body);
+    const sentHeaderSecrets = headerSecrets(headers);
+    const record = (outcome) => {
+        const fetches = (host.fetches ??= []);
+        if (fetches.length >= MAX_FETCHES)
+            return undefined;
+        const connection = ai?.connection ?? found?.connection;
+        const secrets = [...sentHeaderSecrets, ...secretsOf(host)].sort((a, b) => b.length - a.length);
+        const bodyRoom = Math.min(MAX_BODY_CHARS, MAX_LOGGED_CHARS - (host.fetchLogChars ?? 0));
+        const requestBody = sentBody !== undefined && bodyRoom > 0 ? loggable(sentBody, secrets, bodyRoom) : undefined;
+        if (requestBody)
+            host.fetchLogChars = (host.fetchLogChars ?? 0) + requestBody.length;
+        const entry = {
+            at: startedAt,
+            method,
+            url: loggable(redactedUrl(url, secrets), secrets, MAX_URL_CHARS),
+            durationMs: Date.now() - startedAt,
+            ...(requestBody !== undefined && { requestBody }),
+            ...(outcome.status !== undefined && { status: outcome.status }),
+            ...(outcome.error !== undefined && {
+                error: loggable(outcome.error instanceof Error ? outcome.error.message : String(outcome.error), secrets, MAX_ERROR_CHARS),
+            }),
+            ...(connection && { connection }),
+            ...(ai && { ziteAi: true }),
+            ...(outcome.retried && { retried: true }),
+        };
+        fetches.push(entry);
+        return entry;
+    };
+    if (!ai && !found) {
+        try {
+            // The app's own call, `cf` and all; only the headers are ours.
+            const response = await nativeFetch(input, { ...init, headers });
+            record({ status: response.status });
+            return response;
+        }
+        catch (error) {
+            record({ error });
+            throw error;
+        }
+    }
+    // An org's own AI key, which classic reads usage from for analytics.
+    const usageProvider = found ? AI_USAGE_HOSTS[url.hostname] : undefined;
+    const usageBody = usageProvider ? withStreamUsage(url, method, init?.body) : undefined;
+    if (usageBody !== undefined)
+        headers.delete("content-length");
+    const base = new Request(input, usageBody === undefined ? init : { ...init, body: usageBody });
+    if (ai) {
+        try {
+            const session = await sessionOf(host);
+            if (!session?.aiFetch) {
+                const refused = aiUnavailable();
+                record({ status: refused.status });
+                return refused;
+            }
+            // Whole, so it crosses RPC as bytes whatever stream the app built it from.
+            const body = base.body ? await base.arrayBuffer() : undefined;
+            const response = await session.aiFetch(new Request(ai.target, { method: base.method, headers, body, redirect: "manual" }));
+            record({ status: response.status });
+            return response;
+        }
+        catch (error) {
+            record({ error });
+            throw error;
+        }
+    }
+    // As classic: Node SDKs ask for gzip and inflate it themselves, which fails on the body Workers already inflated.
+    if (found)
+        headers.delete("accept-encoding");
+    const outgoing = new Request(base, { headers });
+    const retry = found ? outgoing.clone() : undefined;
+    try {
+        let response = await nativeFetch(outgoing);
+        let retried = false;
+        if (response.status === 401 && retry && found) {
+            const fresh = await freshToken(host, found.token, found.connection);
+            if (fresh) {
+                const retryHeaders = new Headers(retry.headers);
+                swapHeaders(retryHeaders, found.token, fresh);
+                await response.body?.cancel();
+                response = await nativeFetch(new Request(withQueryValue(url, found.token, fresh), {
+                    method: retry.method,
+                    headers: retryHeaders,
+                    body: retry.body,
+                    redirect: retry.redirect,
+                    signal: retry.signal,
+                    ...(retry.body && { duplex: "half" }),
+                    ...(cfOf(retry) !== undefined && { cf: cfOf(retry) }),
+                }));
+                retried = true;
+            }
+        }
+        if (!retried)
+            await retry?.body?.cancel();
+        if (usageProvider) {
+            const metered = meterAiResponse(usageProvider, response);
+            response = metered.response;
+            const entry = record({ status: response.status, retried });
+            const used = metered.usage.then((usage) => {
+                if (usage && entry)
+                    entry.ai = usage;
+            });
+            (host.pending ??= []).push(settledWithin(used, USAGE_WAIT_MS));
+            return response;
+        }
+        record({ status: response.status, retried });
+        return response;
+    }
+    catch (error) {
+        await retry?.body?.cancel().catch(() => { });
+        record({ error });
+        throw error;
+    }
+};

package/dist/esm/start/redactSecrets.d.ts

@@ -5,3 +5,11 @@ export declare const REDACTED = "REDACTED";
  * callers that pass clean text see byte-identical output.
  */
 export declare function redactSecrets(text: string): string;
+/** The ways a secret is written into text, longest first: as it is, URL-encoded in either case, form-encoded, JSON-escaped. */
+export declare function secretForms(value: string): string[];
+/**
+ * `text` with each of `values`, however it was written, replaced, then
+ * anything the patterns above find. `values` longest first, so none is left
+ * half-done.
+ */
+export declare function redactKnown(text: string, values: readonly string[]): string;

package/dist/esm/start/redactSecrets.js

@@ -129,3 +129,26 @@ export function redactSecrets(text) {
     }
     return result;
 }
+/** The ways a secret is written into text, longest first: as it is, URL-encoded in either case, form-encoded, JSON-escaped. */
+export function secretForms(value) {
+    const lower = (text) => text.replace(/%[0-9A-F]{2}/g, (hex) => hex.toLowerCase());
+    const encoded = encodeURIComponent(value);
+    const form = new URLSearchParams({ v: value }).toString().slice(2);
+    const json = JSON.stringify(value).slice(1, -1);
+    return [...new Set([value, encoded, lower(encoded), form, lower(form), json])].sort((a, b) => b.length - a.length);
+}
+/**
+ * `text` with each of `values`, however it was written, replaced, then
+ * anything the patterns above find. `values` longest first, so none is left
+ * half-done.
+ */
+export function redactKnown(text, values) {
+    let result = text;
+    for (const value of values) {
+        for (const form of secretForms(value)) {
+            if (result.includes(form))
+                result = result.split(form).join(REDACTED);
+        }
+    }
+    return redactSecrets(result);
+}

package/dist/esm/start/server.d.ts

@@ -1,3 +1,4 @@
+import { type CredentialSource } from "./credentials.js";
 import type { HostProps, PlatformBinding, RenderWatch, ZiteRequestContext } from "./types.js";
 export { runWithHost } from "./scope.js";
 export { describeApp } from "./describe.js";
@@ -39,6 +40,8 @@ export type ZiteServerOptions = {
     startInstance?: {
         getOptions: () => unknown;
     };
+    /** Where `integrations.get` reads outside Zite; the host's requests always read the host. */
+    credentials?: CredentialSource;
 };
 type HostedContext = WorkerContext & {
     props?: Partial<HostProps>;

package/dist/esm/start/server.js

@@ -10,6 +10,8 @@ import { errorOf, preview } from "./runLog.js";
 import { DATA_INTEGRATION_ID, dataContextOf, runDataCall } from "./data/index.js";
 import { airtableSettingsOf, runAirtableCall } from "./airtable/index.js";
 import { withoutConsole } from "./quiet.js";
+import { createOutboundFetch, rememberConnection } from "./outbound.js";
+import { INTEGRATIONS_PLATFORM_ID } from "./credentials.js";
 import { getHost, requireScope, runInScope, runWithHost } from "./scope.js";
 import { ZITEJS_VERSION } from "./version.js";
 import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
@@ -25,6 +27,11 @@ export function installPlatformTransport() {
     const sdkCall = async (integrationId, className, methodName, params) => {
         const scope = requireScope(`${className}.${methodName}`);
         const host = getHost();
+        const getsConnection = integrationId === INTEGRATIONS_PLATFORM_ID && methodName === "get";
+        const name = String(params?.name ?? "");
+        // An app run outside Zite reads its connections from its own source, with no platform at all.
+        if (getsConnection && host?.credentials)
+            return connectionAnswer(host, name, await host.credentials.get(name));
         // Fails closed: no platform means no platform access, never a fallback.
         if (!host?.platform)
             throw new Error("The Zite platform binding is missing");
@@ -43,6 +50,8 @@ export function installPlatformTransport() {
             }
         }
         const result = await session.call({ integrationId, className, methodName, params, access: scope.kind });
+        if (getsConnection)
+            return connectionAnswer(host, name, result);
         if ("value" in result)
             return result.value;
         const { code, message, userFacingMessage } = result.error;
@@ -51,6 +60,15 @@ export function installPlatformTransport() {
     globalThis.__wrapSdkCall = sdkCall;
     watchOutboundFetches();
 }
+/** `integrations.get`'s answer, whose values then name the calls made with them. */
+const connectionAnswer = (host, name, result) => {
+    if ("value" in result) {
+        rememberConnection(host, name, result.value);
+        return result.value;
+    }
+    const { code, message, userFacingMessage } = result.error;
+    throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
+};
 /** A data call the app made itself, recorded as the host recorded the ones it made. */
 const recordCall = async (host, call, run) => {
     const at = Date.now();
@@ -72,28 +90,15 @@ const recordCall = async (host, call, run) => {
         throw error;
     }
 };
-let fetchesWatched = false;
-const fetchedHost = (input) => {
-    try {
-        return new URL(input instanceof Request ? input.url : input).host;
-    }
-    catch {
-        return "?";
-    }
-};
-// A page that fetched depends on more than the reads the host saw, so the host
-// must hear of it before the fetch goes out. Next patches fetch for the same reason.
+// Keyed on globalThis so two copies of zitejs in one bundle wrap fetch once.
+const WATCHED_KEY = Symbol.for("zitejs:outbound-fetch");
+// Next patches fetch for the same reasons: the page cache must hear of each, and the run log too.
 const watchOutboundFetches = () => {
-    if (fetchesWatched)
+    const marks = globalThis;
+    if (marks[WATCHED_KEY])
         return;
-    fetchesWatched = true;
-    const nativeFetch = globalThis.fetch.bind(globalThis);
-    globalThis.fetch = async (input, init) => {
-        const watch = getHost()?.watch;
-        if (watch)
-            await watch.uncacheable(`fetch ${fetchedHost(input)}`);
-        return nativeFetch(input, init);
-    };
+    marks[WATCHED_KEY] = true;
+    globalThis.fetch = createOutboundFetch(globalThis.fetch.bind(globalThis));
 };
 const decodeUser = (value) => JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
 const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "register", "warm", "authHook", "function"]);
@@ -111,6 +116,7 @@ export function hostContextFromProps(request, props) {
         baseId: props.baseId,
         previewClaim: props.previewClaim,
         env: props.env,
+        envConnections: props.envConnections,
         runRoot: props.runRoot,
         runs: [],
         platform: props.platform,
@@ -300,7 +306,7 @@ export function createZiteHandlers(options) {
     const serve = async (request, ctx, watch) => {
         const host = ctx?.props?.platform
             ? hostContextFromProps(request, ctx.props)
-            : hostContextFromRequest(request, options.platform);
+            : { ...hostContextFromRequest(request, options.platform), credentials: options.credentials };
         if (watch)
             host.watch = watch;
         setRequestEnv(host);
@@ -332,14 +338,21 @@ export function createZiteHandlers(options) {
             response = new Response(response.body, { status, headers: response.headers });
         return onBodyEnd(response, () => {
             const { platform } = host;
-            if ((!host.runs.length && !host.calls?.length && !host.pending?.length) || !platform)
+            if ((!host.runs.length && !host.calls?.length && !host.fetches?.length && !host.pending?.length) || !platform)
                 return;
             // On the request's session when it has one: one call, not another binding round trip.
             const flushed = (async () => {
                 await Promise.all(host.pending ?? []);
-                if (!host.runs.length && !host.calls?.length)
+                if (!host.runs.length && !host.calls?.length && !host.fetches?.length)
                     return;
-                const batch = { runs: host.runs, ...(host.calls?.length && { calls: host.calls }) };
+                const batch = {
+                    runs: host.runs,
+                    ...(host.calls?.length && { calls: host.calls }),
+                    ...(host.fetches?.length && { fetches: host.fetches }),
+                };
+                // Only a session takes fetches.
+                if (host.fetches?.length)
+                    host.session ??= Promise.resolve(platform.session());
                 const session = host.session ? await host.session : undefined;
                 await (session?.runs ? session.runs(batch) : platform.runs(batch));
             })().catch((error) => {

package/dist/esm/start/types.d.ts

@@ -1,3 +1,5 @@
+import type { AiUsageRecord } from "./aiUsage.js";
+import type { CredentialSource } from "./credentials.js";
 export type Role = {
     id: string;
     name: string;
@@ -76,13 +78,37 @@ export type CallRecord = {
         message: string;
     };
 };
+/** An outbound fetch, by host and path (never its query), with the connection whose token it carried. */
+export type FetchRecord = {
+    at: number;
+    method: string;
+    /** Whole, with every secret the request knows redacted. */
+    url: string;
+    /** As classic's run log shows it: cut short, secrets redacted. */
+    requestBody?: string;
+    status?: number;
+    durationMs: number;
+    error?: string;
+    connection?: string;
+    /** Sent again with a refreshed token after a 401. */
+    retried?: true;
+    /** On Zite's own AI key, which the host meters itself. */
+    ziteAi?: true;
+    /** What a call on the org's own AI key used, for analytics. */
+    ai?: AiUsageRecord;
+};
 export type PlatformSession = {
     call(call: PlatformCallInput): Promise<PlatformCallResult>;
-    /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it. */
+    /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it; before 0.10.0-start.13, `fetches`. */
     runs?(batch: {
         runs: RunRecord[];
         calls?: CallRecord[];
+        fetches?: FetchRecord[];
     }): Promise<void>;
+    /** After a provider answered 401: the connection refreshed, as `integrations.get` now answers it. Hosts before 0.10.0-start.13 lack it. */
+    refreshConnection?(name: string): Promise<PlatformCallResult>;
+    /** A call on Zite's own AI key, which the host makes with the real key. Hosts before 0.10.0-start.13 lack it. */
+    aiFetch?(request: Request): Promise<Response>;
     /** The build's base and SDK names, which the app's data dispatch translates against. */
     dataContext?(): Promise<{
         baseId: string | null;
@@ -136,8 +162,10 @@ export type HostProps = {
     baseId?: string;
     /** An editor preview's access, which zitejs keeps on the app's links and calls. */
     previewClaim?: string;
-    /** `process.env` as classic sets it: connections' vars, secrets as placeholders egress swaps but S3's, then the user's own secrets. */
+    /** `process.env` as classic sets it: connections' vars, then the user's own secrets. */
     env?: Record<string, string>;
+    /** Which connection each token var in `env` holds. Hosts before 0.10.0-start.13 don't send it. */
+    envConnections?: Record<string, string>;
     /** A resumed run's first attempt, whose saved steps it replays. Hosts before 0.10.0-start.10 don't send it. */
     runRoot?: string;
 };
@@ -153,8 +181,25 @@ export type ZiteRequestContext = {
     previewClaim?: string;
     /** Classic's connection env vars the host sent, set into `process.env` for the request. */
     env?: Record<string, string>;
+    envConnections?: Record<string, string>;
     /** A resumed run's first attempt, whose saved steps it replays. */
     runRoot?: string;
+    /** Where `integrations.get` reads, when not the host: an entry run outside Zite's names its own. */
+    credentials?: CredentialSource;
+    /** The connection each token this request was handed belongs to. */
+    connectionTokens?: Map<string, string>;
+    /** `integrations.get`'s answers this request, by name. */
+    connectionAnswers?: Map<string, unknown>;
+    /** One refresh per connection per request, however many calls got a 401. */
+    refreshing?: Map<string, Promise<string | undefined>>;
+    /** The outbound fetches, flushed with its runs. */
+    fetches?: FetchRecord[];
+    /** The secrets its fetch log redacts, longest first; cleared when a connection is learned. */
+    secretValues?: string[];
+    /** The isolate's refresh count `secretValues` was read at. */
+    secretsAt?: number;
+    /** How much of its fetch log is bodies so far. */
+    fetchLogChars?: number;
     /** Filled by run capture, flushed to the platform once the response ends. */
     runs: RunRecord[];
     /** The data calls this request made, flushed with its runs. */

package/dist/esm/start/version.d.ts

@@ -1 +1 @@
-export declare const ZITEJS_VERSION = "0.10.0-start.12";
+export declare const ZITEJS_VERSION = "0.10.0-start.13";

package/dist/esm/start/version.js

@@ -1,2 +1,2 @@
 // Written by scripts/write-version.mjs from package.json.
-export const ZITEJS_VERSION = "0.10.0-start.12";
+export const ZITEJS_VERSION = "0.10.0-start.13";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.10.0-start.12",
+  "version": "0.10.0-start.13",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,