@playcademy/better-auth 0.0.1 → 0.0.3-beta.1

package/dist/client.d.ts

@@ -18,7 +18,6 @@
  * })
  * ```
  */
-import { playcademy as playcademyServerPlugin } from './server';
 /**
  * Configuration options for the Playcademy Better Auth client plugin
  *
@@ -138,6 +137,54 @@ export interface PlaycademyClientOptions {
  */
 export declare function playcademy(options?: PlaycademyClientOptions): {
     id: "playcademy-client";
-    $InferServerPlugin: ReturnType<typeof playcademyServerPlugin>;
+    $InferServerPlugin: {
+        id: string;
+        schema: {
+            user: {
+                fields: {
+                    playcademyUserId: {
+                        type: "string";
+                        unique: boolean;
+                        required: boolean;
+                    };
+                };
+            };
+        };
+        endpoints: {
+            playcademyAuth: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                    body?: undefined;
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any> | undefined;
+                } & {
+                    request?: Request | undefined;
+                } & {
+                    headers?: HeadersInit | undefined;
+                } & {
+                    asResponse?: boolean | undefined;
+                    returnHeaders?: boolean | undefined;
+                    use?: any[] | undefined;
+                    path?: string | undefined;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: Response;
+                } : Response>;
+                options: {
+                    method: "POST";
+                    requireHeaders: false;
+                } & {
+                    use: any[];
+                };
+                path: "/playcademy";
+            };
+        };
+    };
     fetchPlugins: import("@better-fetch/fetch").BetterFetchPlugin[];
 };

package/dist/client.js

@@ -11,23 +11,27 @@ var __export = (target, all) => {
 
 // src/utils.ts
 function isPlatformMode() {
-  if (typeof window === "undefined")
+  if (typeof globalThis.window === "undefined") {
     return false;
-  if (window.self === window.top)
+  }
+  if (globalThis.self === window.top) {
     return false;
+  }
   return true;
 }
 function isSafari() {
-  if (typeof window === "undefined")
+  if (typeof globalThis.window === "undefined") {
     return false;
+  }
   const ua = navigator.userAgent;
   return ua.includes("Safari") && !ua.includes("Chrome") && !ua.includes("Chromium");
 }
 function getPlatformToken() {
-  if (typeof window === "undefined")
+  if (typeof globalThis.window === "undefined") {
     return null;
+  }
   try {
-    return window.PLAYCADEMY?.token || null;
+    return globalThis.PLAYCADEMY?.token || null;
   } catch {
     return null;
   }
@@ -36,12 +40,15 @@ function hasStorageAccessAPI() {
   return typeof document !== "undefined" && "hasStorageAccess" in document;
 }
 async function needsStorageAccess() {
-  if (!isPlatformMode())
+  if (!isPlatformMode()) {
     return false;
-  if (!isSafari())
+  }
+  if (!isSafari()) {
     return false;
-  if (!hasStorageAccessAPI())
+  }
+  if (!hasStorageAccessAPI()) {
     return false;
+  }
   try {
     const hasAccess = await document.hasStorageAccess();
     return !hasAccess;
@@ -50,8 +57,9 @@ async function needsStorageAccess() {
   }
 }
 async function requestStorageAccess() {
-  if (!hasStorageAccessAPI())
+  if (!hasStorageAccessAPI()) {
     return false;
+  }
   try {
     await document.requestStorageAccess();
     return true;
@@ -62,8 +70,9 @@ async function requestStorageAccess() {
 
 // src/fetch.ts
 async function ensureStorageAccess() {
-  if (!isSafari())
+  if (!isSafari()) {
     return true;
+  }
   const needs = await needsStorageAccess();
   if (needs) {
     return false;
@@ -72,8 +81,8 @@ async function ensureStorageAccess() {
     await document.requestStorageAccess();
     await new Promise((resolve) => setTimeout(resolve, 50));
     return true;
-  } catch (err) {
-    console.error("[Playcademy Auth] Safari Storage Access activation failed:", err);
+  } catch (error) {
+    console.error("[Playcademy Auth] Safari Storage Access activation failed:", error);
     return false;
   }
 }
@@ -104,26 +113,40 @@ function playcademyExchangePlugin(_opts) {
     id: "playcademy-exchange",
     name: "Playcademy Exchange",
     async init(url, options) {
-      if (exchangeComplete)
+      if (exchangeComplete) {
         return { url, options };
+      }
       if (exchangePromise) {
         await exchangePromise;
         return { url, options };
       }
       exchangePromise = (async () => {
         const token = await waitForToken();
-        if (!token)
+        if (!token) {
           return;
+        }
         const canProceed = await ensureStorageAccess();
         if (!canProceed) {
           return;
         }
-        await fetch("/api/auth/playcademy", {
-          method: "POST",
-          headers: { Authorization: `Bearer ${token}` },
-          credentials: "include"
-        });
-        exchangeComplete = true;
+        try {
+          const headers = { Authorization: `Bearer ${token}` };
+          if (isPlatformMode()) {
+            headers["X-Playcademy-Mode"] = "platform";
+          }
+          const response = await fetch("/api/auth/playcademy", {
+            method: "POST",
+            headers,
+            credentials: "include"
+          });
+          if (response.status === 204) {
+            exchangeComplete = true;
+          } else if (response.status !== 200 && response.status !== 500) {
+            console.warn(`[Playcademy Auth] Unexpected response status: ${response.status}`);
+          }
+        } catch (error) {
+          console.warn("[Playcademy Auth] Network error during token exchange:", error);
+        }
       })();
       await exchangePromise;
       return { url, options };
@@ -140,8 +163,9 @@ function removeOverlay() {
   }
 }
 function injectStorageAccessOverlay() {
-  if (document.getElementById(OVERLAY_ID))
+  if (document.getElementById(OVERLAY_ID)) {
     return;
+  }
   if (!document.body) {
     document.addEventListener("DOMContentLoaded", injectStorageAccessOverlay);
     return;
@@ -225,7 +249,7 @@ function injectStorageAccessOverlay() {
           const hasAccess = await document.hasStorageAccess();
           if (hasAccess) {
             removeOverlay();
-            window.location.reload();
+            globalThis.location.reload();
             return;
           }
         } catch {}
@@ -233,7 +257,7 @@ function injectStorageAccessOverlay() {
       const granted = await requestStorageAccess();
       if (granted) {
         removeOverlay();
-        window.location.reload();
+        globalThis.location.reload();
       } else {
         const message = overlay.querySelector(`#${OVERLAY_ID}-message`);
         if (message) {
@@ -245,10 +269,12 @@ function injectStorageAccessOverlay() {
   document.body.appendChild(overlay);
 }
 async function handleStorageAccess(options) {
-  if (!options.autoPrompt)
+  if (!options.autoPrompt) {
     return;
-  if (!isPlatformMode() || !isSafari())
+  }
+  if (!isPlatformMode() || !isSafari()) {
     return;
+  }
   const needs = await needsStorageAccess();
   if (needs) {
     injectStorageAccessOverlay();
@@ -260,7 +286,7 @@ function playcademy(options) {
       autoPrompt: options?.safari?.autoPrompt ?? true
     }
   };
-  if (typeof window !== "undefined" && opts.safari.autoPrompt) {
+  if (typeof globalThis.window !== "undefined" && opts.safari.autoPrompt) {
     if (isPlatformMode() && isSafari()) {
       setTimeout(() => {
         handleStorageAccess(opts.safari);

package/dist/server.d.ts

@@ -17,7 +17,7 @@
  * 1. **Platform Mode (iframe)**:
  *    - Game receives JWT token from Playcademy platform
  *    - Client exchanges token via `/api/auth/playcademy` endpoint
- *    - Server verifies token with platform API
+ *    - Server verifies token with platform API (uses PLAYCADEMY_BASE_URL env var)
  *    - Creates or links Better Auth user by `playcademyUserId`
  *    - Returns session cookie with CHIPS support
  *
@@ -30,6 +30,15 @@
  *    - If a user exists with that `playcademyUserId`, sessions merge
  *    - Enables seamless switching between platform and standalone
  *
+ * **Development/Testing**:
+ *
+ * To test deployed games against a local platform API, set the `PLAYCADEMY_AUTH_API_URL`
+ * environment variable to override the platform URL (e.g., using a tunnel service):
+ *
+ * ```bash
+ * PLAYCADEMY_AUTH_API_URL=https://your-tunnel.dev
+ * ```
+ *
  * **Cookie Configuration**:
  *
  * For cross-origin iframe authentication to work, you MUST configure cookies:
@@ -131,15 +140,15 @@
  * }
  * ```
  */
-export declare const playcademy: () => {
-    id: "playcademy";
+export declare function playcademy(): {
+    id: string;
     schema: {
         user: {
             fields: {
                 playcademyUserId: {
                     type: "string";
-                    unique: true;
-                    required: false;
+                    unique: boolean;
+                    required: boolean;
                 };
             };
         };
@@ -168,16 +177,16 @@ export declare const playcademy: () => {
             } & {
                 query?: Record<string, any> | undefined;
             } & {
-                params?: Record<string, any>;
+                params?: Record<string, any> | undefined;
             } & {
-                request?: Request;
+                request?: Request | undefined;
             } & {
-                headers?: HeadersInit;
+                headers?: HeadersInit | undefined;
             } & {
-                asResponse?: boolean;
-                returnHeaders?: boolean;
-                use?: import("better-call").Middleware[];
-                path?: string;
+                asResponse?: boolean | undefined;
+                returnHeaders?: boolean | undefined;
+                use?: any[] | undefined;
+                path?: string | undefined;
             } & {
                 asResponse?: AsResponse | undefined;
                 returnHeaders?: ReturnHeaders | undefined;