@hosty-sdk/app 0.19.1 → 0.21.0

package/dist/activity-react.d.ts

@@ -1,7 +1,11 @@
+import type { AppAuthProtocol } from "./app-code.js";
 /** Keep mounted beside app content so expiry never discards drafts or component state. */
-export declare function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityRequired }: {
+export declare function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityRequired, appAuthProtocol, probePath, native }: {
     openUrl: string;
     appCodePath: string;
     activeUntil?: string | null;
     activityRequired?: boolean;
+    appAuthProtocol?: AppAuthProtocol | null;
+    probePath?: string;
+    native?: boolean;
 }): import("react").JSX.Element | null;

package/dist/activity-react.js

@@ -3,8 +3,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { AuthNotice, AuthNoticeButton } from "./auth-notice.js";
 import { APP_SESSION_ENDED, APP_ACTIVITY_RENEWED, appActivityNeedsRenewal, configureAppActivity, updateAppActivity, renewAppActivity, cancelActivityRenewal } from "./browser-auth.js";
+import { resolveLaunchMode, detectLaunchMode, normalizeLaunchMode, LAUNCH_MODE_ATTRIBUTE, LAUNCH_MODE_PARAM, LAUNCH_MODE_STORAGE_KEY } from "./index.js";
+import { acceptAppAuthProtocol, refreshAppAuthProtocol } from "./browser-auth.js";
 /** Keep mounted beside app content so expiry never discards drafts or component state. */
-export function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityRequired = false }) {
+export function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityRequired = false, appAuthProtocol, probePath = "/api/auth/identity", native }) {
     const [needed, setNeeded] = useState(false);
     const [pending, setPending] = useState(false);
     const [error, setError] = useState("");
@@ -15,14 +17,35 @@ export function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityR
         void operation.catch(e => { setNeeded(true); setError(String(e.message ?? e)); }).finally(() => setPending(false));
     };
     useEffect(() => {
-        const cleanup = configureAppActivity({ openUrl, exchangeCode: async (code) => {
-                const response = await fetch(appCodePath, { method: "POST", credentials: "same-origin", redirect: "error",
-                    headers: { "Content-Type": "application/json" }, body: JSON.stringify({ code }) });
-                const body = await response.json();
-                if (!response.ok)
-                    throw new Error(body.message ?? "Could not renew app activity.");
-                return body;
-            } });
+        let cancelled = false;
+        let cleanup;
+        const controller = new AbortController();
+        const configure = (protocol) => {
+            if (cancelled || !protocol || acceptAppAuthProtocol(new URL(openUrl).origin, protocol) !== protocol)
+                return;
+            let stored = null;
+            try {
+                stored = window.sessionStorage.getItem(LAUNCH_MODE_STORAGE_KEY);
+            }
+            catch { /* The applied document mode remains available. */ }
+            const mode = normalizeLaunchMode(document.documentElement.getAttribute(LAUNCH_MODE_ATTRIBUTE)) ?? resolveLaunchMode({
+                param: new URL(window.location.href).searchParams.get(LAUNCH_MODE_PARAM), stored, heuristic: detectLaunchMode(window),
+            }).mode;
+            cleanup = configureAppActivity({ openUrl, appAuthProtocol: protocol, probePath, native: native ?? mode === "native", activeUntil, activityRequired, exchangeCode: async (proof) => {
+                    const response = await fetch(appCodePath, { method: "POST", credentials: "same-origin", redirect: "error",
+                        headers: { "Content-Type": "application/json" }, body: JSON.stringify(proof) });
+                    const body = await response.json();
+                    if (!response.ok)
+                        throw new Error(body.message ?? "Could not renew app activity.");
+                    return body;
+                } });
+        };
+        if (appAuthProtocol !== undefined && !(appAuthProtocol === 1 && acceptAppAuthProtocol(new URL(openUrl).origin, 1) === null))
+            configure(appAuthProtocol);
+        else
+            void refreshAppAuthProtocol(openUrl, probePath, controller.signal).then(configure);
+        // A stale protocol-1 prop cannot overwrite a protocol-2 minimum already verified
+        // by this app. Unknown discovery leaves renewal disabled instead of downgrading.
         const expired = () => setNeeded(true);
         const renewed = () => { setNeeded(false); setError(""); };
         const click = (event) => {
@@ -35,8 +58,8 @@ export function AppActivityBridge({ openUrl, appCodePath, activeUntil, activityR
         window.addEventListener(APP_SESSION_ENDED, expired);
         window.addEventListener(APP_ACTIVITY_RENEWED, renewed);
         document.addEventListener("click", click, true);
-        return () => { cleanup(); window.removeEventListener(APP_SESSION_ENDED, expired); window.removeEventListener(APP_ACTIVITY_RENEWED, renewed); document.removeEventListener("click", click, true); };
-    }, [openUrl, appCodePath]);
+        return () => { cancelled = true; controller.abort(); cleanup?.(); window.removeEventListener(APP_SESSION_ENDED, expired); window.removeEventListener(APP_ACTIVITY_RENEWED, renewed); document.removeEventListener("click", click, true); };
+    }, [openUrl, appCodePath, appAuthProtocol, probePath, native]);
     useEffect(() => { updateAppActivity(activeUntil, activityRequired); }, [activeUntil, activityRequired, openUrl, appCodePath]);
     if (!needed)
         return null;

package/dist/app-code.d.ts

@@ -0,0 +1,6 @@
+/** Shared by framework server adapters and plain Node apps. Never sends an app credential. */
+export type AppAuthProtocol = 1 | 2;
+export declare function isValidCodeVerifier(value: unknown): value is string;
+export declare function appAuthProtocolMinimum(coreOrigin: string | null): 2 | null;
+/** A 404 alone is insufficient: only an identified, older Core permits the old navigation. */
+export declare function resolveAppAuthProtocol(coreOrigin: string | null): Promise<AppAuthProtocol | null>;

package/dist/app-code.js

@@ -0,0 +1,80 @@
+export function isValidCodeVerifier(value) {
+    return typeof value === "string" && /^[A-Za-z0-9._~-]{43,128}$/.test(value);
+}
+const minimumProtocols = new Set();
+const discoveries = new Map();
+export function appAuthProtocolMinimum(coreOrigin) {
+    try {
+        return minimumProtocols.has(new URL(coreOrigin ?? "").origin) ? 2 : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isOlderCoreVersion(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/.exec(value);
+    if (!match)
+        return false;
+    for (const [index, suffix] of [[4, match[4]], [5, match[5]]]) {
+        if (suffix && suffix.split(".").some(part => !/^[0-9A-Za-z-]+$/.test(part) || (index === 4 && /^0\d+$/.test(part))))
+            return false;
+    }
+    const major = Number(match[1]), minor = Number(match[2]), patch = Number(match[3]);
+    return [major, minor, patch].every(Number.isSafeInteger) && major === 0 && minor < 120;
+}
+/** A 404 alone is insufficient: only an identified, older Core permits the old navigation. */
+export async function resolveAppAuthProtocol(coreOrigin) {
+    let origin;
+    try {
+        const parsed = new URL(coreOrigin ?? "");
+        if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password ||
+            parsed.pathname !== "/" || parsed.search || parsed.hash)
+            return null;
+        origin = parsed.origin;
+    }
+    catch {
+        return null;
+    }
+    const pending = discoveries.get(origin);
+    if (pending)
+        return pending;
+    const operation = (async () => {
+        const request = (path) => fetch(new URL(path, origin), {
+            cache: "no-store", redirect: "error", headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(1_500),
+        });
+        try {
+            const response = await request("/api/auth/apps/protocol");
+            if (response.status === 200) {
+                if (!response.headers.get("content-type")?.toLowerCase().startsWith("application/json"))
+                    return null;
+                const body = await response.json().catch(() => null);
+                if (body?.version !== 2)
+                    return null;
+                minimumProtocols.add(origin);
+                return 2;
+            }
+            if (response.status !== 404 || minimumProtocols.has(origin))
+                return null;
+            const status = await request("/api/core/status");
+            if (status.status !== 200)
+                return null;
+            if (!status.headers.get("content-type")?.toLowerCase().startsWith("application/json"))
+                return null;
+            const body = await status.json().catch(() => null);
+            return body?.component === "hosty-core" && body.status === "running" && isOlderCoreVersion(body.version) ? 1 : null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    discoveries.set(origin, operation);
+    try {
+        return await operation;
+    }
+    finally {
+        discoveries.delete(origin);
+    }
+}

package/dist/browser-auth.d.ts

@@ -1,17 +1,58 @@
+import type { AppAuthProtocol } from "./app-code.js";
+export type AppSignInResult = {
+    code: string;
+    codeVerifier: string;
+};
+export type AppAuthAttempt = {
+    state: string;
+    codeVerifier: string;
+    codeChallenge: string;
+    appId: string;
+    coreOrigin: string;
+    redirectUri: string;
+    createdAt: number;
+    mode: "standalone" | "silent" | "popup" | "native";
+    protocol: AppAuthProtocol;
+};
+export declare const APP_AUTH_ATTEMPT_PREFIX = "hosty.auth.attempt:";
+export declare function appCodeChallenge(verifier: string): string;
+export declare function acceptAppAuthProtocol(coreOrigin: string, protocol: AppAuthProtocol | null): AppAuthProtocol | null;
+export declare function createAppAuthAttempt(openUrl: string, mode: AppAuthAttempt["mode"], protocol: AppAuthProtocol): AppAuthAttempt;
+/** Do not leave the app document unless this exact proof survives a storage round trip. */
+export declare function persistAppAuthAttempt(attempt: AppAuthAttempt): boolean;
+/** Correlation is local; URL fields never supply a verifier or a pending attempt. */
+export declare function takeAppAuthAttempt(callback: URL, allowLegacyUpgrade?: boolean): AppAuthAttempt | null;
+export declare function clearAppAuthAttempts(): void;
+export declare function appAuthNavigationUrl(attempt: AppAuthAttempt): string;
+/** Constant document and DOM-built fields prevent a public URL from laundering a challenge. */
+export declare function submitAppAuthIntent(attempt: AppAuthAttempt, doc?: Document): void;
 export declare const APP_SESSION_ENDED = "hosty:app-session-ended";
+export declare const NATIVE_APP_AUTH_RESULT = "hosty:native-auth-result";
+export declare const APP_GRANT_STORAGE_KEY = "hosty.auth.app-grant";
+/** Restore before the first identity probe; standalone documents use their first-party cookie. */
+export declare function restoreAppGrant(): boolean;
 export declare function rememberAppGrant(token: string): void;
 export declare function forgetAppGrant(): void;
+/** Snapshot the grant generation so older probes cannot invalidate a renewed identity. */
+export declare function appGrantRevision(): number;
+/** Activity expiry keeps identity; only explicit identity rejection discards the credential. */
+export declare function forgetRejectedAppGrant(code: unknown, expectedRevision?: number): boolean;
 export declare function appSessionActive(): void;
 /** Use for app-local API calls, including streams. Redirects cannot carry the credential away. */
 export declare function appFetch(input: string | URL, init?: RequestInit, recover?: boolean): Promise<Response>;
-/** Must be called directly from a user gesture. The popup belongs to this app frame, not Shell. */
-export declare function openAppSignIn(openUrl: string, signal?: AbortSignal): Promise<string>;
+/** Refresh only the app-local, server-verified metadata for this frozen app/Core pair. */
+export declare function refreshAppAuthProtocol(openUrl: string, probePath?: string, signal?: AbortSignal): Promise<AppAuthProtocol | null>;
+/** Must be called directly from a user gesture. Native hosts intercept before any request. */
+export declare function openAppSignIn(openUrl: string, signal?: AbortSignal, appAuthProtocol?: AppAuthProtocol, native?: boolean, probePath?: string): Promise<AppSignInResult>;
 export declare const APP_ACTIVITY_RENEWED = "hosty:app-activity-renewed";
 export type AppActivityConfig = {
     openUrl: string;
+    appAuthProtocol: AppAuthProtocol;
+    native?: boolean;
+    probePath?: string;
     activeUntil?: string | null;
     activityRequired?: boolean;
-    exchangeCode: (code: string) => Promise<{
+    exchangeCode: (result: AppSignInResult) => Promise<{
         accessToken?: string;
         activeUntil?: string | null;
     }>;