zitejs 0.10.0-start.12 → 0.10.0-start.14

package/dist/cjs/internal/appMode.d.ts

@@ -0,0 +1,3 @@
+export declare const keepRenderedMode: (mode: string | undefined) => void;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export declare const platformMode: () => string | undefined;

package/dist/cjs/internal/appMode.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformMode = exports.keepRenderedMode = void 0;
+// Classic's upload client reads this too, so it imports nothing of Start: the
+// request's host comes through the key src/start/host.ts reads it under.
+const HOST_STORE_KEY = Symbol.for("zitejs:host-context");
+// What a Start page was rendered with, kept in the browser when it hydrates.
+const RENDERED_MODE = Symbol.for("zitejs:rendered-mode");
+const keepRenderedMode = (mode) => {
+    globalThis[RENDERED_MODE] = mode;
+};
+exports.keepRenderedMode = keepRenderedMode;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+const platformMode = () => globalThis[HOST_STORE_KEY]?.getStore()?.mode ?? globalThis[RENDERED_MODE];
+exports.platformMode = platformMode;

package/dist/cjs/upload/index.js

@@ -6,6 +6,7 @@ exports.uploadFile = uploadFile;
 exports.useUpload = useUpload;
 const react_1 = require("react");
 const config_js_1 = require("../auth/config.js");
+const appMode_js_1 = require("../internal/appMode.js");
 const constants_js_1 = require("../auth/constants.js");
 class FileUploadError extends Error {
     constructor(message) {
@@ -14,7 +15,16 @@ class FileUploadError extends Error {
     }
 }
 exports.FileUploadError = FileUploadError;
-function getZiteAppMode(hostname) {
+/** As the platform served the page or request; a classic app's from its hostname. */
+function getZiteAppMode() {
+    const served = (0, appMode_js_1.platformMode)();
+    if (served)
+        return served === 'preview' || served === 'validate' ? 'preview' : 'live';
+    // On a server, outside any request the platform served: there's no telling a preview from live.
+    if (typeof window === 'undefined') {
+        throw new FileUploadError('Upload from a page, or from a request the platform is serving');
+    }
+    const { hostname } = window.location;
     const maybeId = hostname.split('.')[0];
     if (maybeId?.startsWith(constants_js_1.ZITE_APP_EDITOR_HOSTNAME_PREFIX))
         return 'preview';
@@ -82,7 +92,7 @@ function authHeaders() {
 }
 async function performUpload(data, filename) {
     const blob = toUploadBlob(data);
-    const mode = getZiteAppMode(window.location.hostname);
+    const mode = getZiteAppMode();
     const flowId = (0, config_js_1.getFlowId)();
     const sessionRes = await fetch((0, config_js_1.getApiUrl)() + '/v1/zite/public/' + flowId + '/upload-session?mode=' + mode, {
         method: 'POST',

package/dist/cjs/upload/index.test.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
+const node_async_hooks_1 = require("node:async_hooks");
+const appMode_js_1 = require("../internal/appMode.js");
 const index_js_1 = require("./index.js");
 vitest_1.vi.mock('../auth/config.js', () => ({
     getApiUrl: () => 'https://api.example.com',
@@ -93,3 +95,40 @@ const fetchMock = vitest_1.vi.fn();
         await (0, vitest_1.expect)(upload).rejects.toThrow('File size exceeds maximum of 20 MB');
     });
 });
+// SDK-10: a Start app's mode is the platform's, never guessed from where the page is served.
+(0, vitest_1.describe)('the mode an upload goes under', () => {
+    const sessionUrl = async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ success: true, presignedUrl: 'https://s3.example.com/put', fileUrl: 'https://uploads.zite.com/f.txt' }),
+        });
+        fetchMock.mockResolvedValueOnce({ ok: true });
+        await (0, index_js_1.uploadFile)({ data: 'hi', filename: 'f.txt' });
+        return String(fetchMock.mock.calls[0][0]);
+    };
+    (0, vitest_1.afterEach)(() => (0, appMode_js_1.keepRenderedMode)(undefined));
+    (0, vitest_1.it)('is the one the page was rendered in, on any host', async () => {
+        (0, appMode_js_1.keepRenderedMode)('preview');
+        (0, vitest_1.expect)(await sessionUrl()).toContain('mode=preview');
+    });
+    (0, vitest_1.it)("is the request's own on the server, where there's no page", async () => {
+        vitest_1.vi.stubGlobal('window', undefined);
+        const store = new node_async_hooks_1.AsyncLocalStorage();
+        globalThis[Symbol.for('zitejs:host-context')] = store;
+        try {
+            (0, vitest_1.expect)(await store.run({ mode: 'validate' }, sessionUrl)).toContain('mode=preview');
+        }
+        finally {
+            delete globalThis[Symbol.for('zitejs:host-context')];
+        }
+    });
+    (0, vitest_1.it)('is refused on a server outside any request the platform served, never guessed as live', async () => {
+        vitest_1.vi.stubGlobal('window', undefined);
+        await (0, vitest_1.expect)((0, index_js_1.uploadFile)({ data: 'hi', filename: 'f.txt' })).rejects.toThrow(index_js_1.FileUploadError);
+        (0, vitest_1.expect)(fetchMock).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("is a classic app's from its hostname, as before", async () => {
+        vitest_1.vi.stubGlobal('window', { location: { hostname: 'zite-editor-app_123.zite.so' } });
+        (0, vitest_1.expect)(await sessionUrl()).toContain('mode=preview');
+    });
+});

package/dist/esm/internal/appMode.d.ts

@@ -0,0 +1,3 @@
+export declare const keepRenderedMode: (mode: string | undefined) => void;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export declare const platformMode: () => string | undefined;

package/dist/esm/internal/appMode.js

@@ -0,0 +1,10 @@
+// Classic's upload client reads this too, so it imports nothing of Start: the
+// request's host comes through the key src/start/host.ts reads it under.
+const HOST_STORE_KEY = Symbol.for("zitejs:host-context");
+// What a Start page was rendered with, kept in the browser when it hydrates.
+const RENDERED_MODE = Symbol.for("zitejs:rendered-mode");
+export const keepRenderedMode = (mode) => {
+    globalThis[RENDERED_MODE] = mode;
+};
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export const platformMode = () => globalThis[HOST_STORE_KEY]?.getStore()?.mode ?? globalThis[RENDERED_MODE];

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

@@ -1,11 +1,8 @@
 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. */
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one. */
 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,44 +1,28 @@
 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;
-const NOT_IMPLEMENTED = /does not implement (?:the )?method/i;
-/** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one. */
 export const airtableSettingsOf = async (session, integrationId) => {
-    if (unsupported || !session.integrationSettings)
-        return undefined;
     if (settingsHeld.has(integrationId))
         return settingsHeld.get(integrationId) ?? undefined;
-    try {
-        const answer = await session.integrationSettings(integrationId);
-        const settings = answer?.serviceType === "airtable" && typeof answer.baseId === "string"
-            ? { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null }
-            : null;
-        settingsHeld.set(integrationId, settings);
-        return settings ?? undefined;
-    }
-    catch (error) {
-        if (error instanceof Error && NOT_IMPLEMENTED.test(error.message)) {
-            unsupported = true;
-            return undefined;
-        }
-        throw error;
-    }
+    const answer = await session.integrationSettings(integrationId);
+    const settings = answer?.serviceType === "airtable" && typeof answer.baseId === "string"
+        ? { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null }
+        : null;
+    settingsHeld.set(integrationId, settings);
+    return settings ?? 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 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,
+        integrationId: INTEGRATIONS_PLATFORM_ID,
         className: "Connections",
         methodName: "get",
         params: { name: integrationId },
@@ -52,6 +36,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,
@@ -66,5 +51,4 @@ export async function runAirtableCall(host, session, integrationId, settings, me
 /** For tests: forget what this isolate learned. */
 export const resetAirtableSettings = () => {
     settingsHeld.clear();
-    unsupported = false;
 };

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

@@ -0,0 +1,2 @@
+/** The platform id `integrations.get` is answered under. */
+export declare const INTEGRATIONS_PLATFORM_ID = "__connections__";

package/dist/esm/start/credentials.js

@@ -0,0 +1,2 @@
+/** The platform id `integrations.get` is answered under. */
+export const INTEGRATIONS_PLATFORM_ID = "__connections__";

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

@@ -6,11 +6,8 @@ type Found = {
     baseId: string | null;
     nameMappings: DataNameMappings | null;
 };
-/**
- * The build's data context, or undefined from a host that predates the app's own
- * dispatch, whose `databases` platform call still answers.
- */
-export declare const dataContextOf: (session: PlatformSession) => Promise<Found | undefined>;
+/** The build's base and SDK names, asked of the platform once per isolate. */
+export declare const dataContextOf: (session: PlatformSession) => Promise<Found>;
 /** One `zite.*` call, translated here and sent to base-runner through the platform. */
 export declare function runDataCall(session: PlatformSession, found: Found, mode: HostMode, methodName: string, sent: unknown): Promise<unknown>;
 /** For tests: forget what this isolate learned. */

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

@@ -8,7 +8,6 @@ const TABLES_REUSE_MS = 60_000;
 // Only answers are kept, never a pending call: one request's RPC session mustn't hold up another's.
 let context;
 let tables;
-let unsupported = false;
 const tablesOf = async (baseRunner, baseId) => {
     if (tables?.baseId === baseId && Date.now() - tables.at < TABLES_REUSE_MS)
         return tables.tables;
@@ -16,29 +15,13 @@ const tablesOf = async (baseRunner, baseId) => {
     tables = { baseId, tables: base.tables, at: Date.now() };
     return base.tables;
 };
-// What Workers RPC throws for a method the host doesn't have yet.
-const NOT_IMPLEMENTED = /does not implement (?:the )?method/i;
-/**
- * The build's data context, or undefined from a host that predates the app's own
- * dispatch, whose `databases` platform call still answers.
- */
+/** The build's base and SDK names, asked of the platform once per isolate. */
 export const dataContextOf = async (session) => {
-    if (unsupported || !session.dataContext || !session.dataFetch)
-        return undefined;
     if (context)
         return context;
-    try {
-        const answer = await session.dataContext();
-        context = { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null };
-        return context;
-    }
-    catch (error) {
-        if (error instanceof Error && NOT_IMPLEMENTED.test(error.message)) {
-            unsupported = true;
-            return undefined;
-        }
-        throw error;
-    }
+    const answer = await session.dataContext();
+    context = { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null };
+    return context;
 };
 /**
  * The table id classic's generated client sends: its SDK name mapped through the
@@ -72,5 +55,4 @@ export async function runDataCall(session, found, mode, methodName, sent) {
 export const resetDataDispatch = () => {
     context = undefined;
     tables = undefined;
-    unsupported = false;
 };

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;