@playcademy/sdk 0.1.12 → 0.1.14

package/dist/index.js

@@ -123,9 +123,13 @@ var isBrowser = () => {
     return false;
   const minLevel = getMinimumLogLevel();
   return levelPriority[level] >= levelPriority[minLevel];
-}, performLog = (level, message, context) => {
+}, customHandler, performLog = (level, message, context) => {
   if (!shouldLog(level))
     return;
+  if (customHandler) {
+    customHandler(level, message, context);
+    return;
+  }
   const outputFormat = detectOutputFormat();
   switch (outputFormat) {
     case "browser":
@@ -278,6 +282,28 @@ function isInIframe() {
 }
 
 // src/core/errors.ts
+function extractApiErrorInfo(error) {
+  if (!(error instanceof ApiError)) {
+    return null;
+  }
+  const info = {
+    status: error.status,
+    statusText: error.message
+  };
+  if (error.details && typeof error.details === "object") {
+    const details = error.details;
+    if ("error" in details && typeof details.error === "string") {
+      info.error = details.error;
+    }
+    if ("message" in details && typeof details.message === "string") {
+      info.message = details.message;
+    }
+    if (!info.error && !info.message) {
+      info.details = error.details;
+    }
+  }
+  return info;
+}
 var PlaycademyError, ApiError;
 var init_errors = __esm(() => {
   PlaycademyError = class PlaycademyError extends Error {
@@ -755,7 +781,7 @@ function createRuntimeNamespace(client) {
     const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
     const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
     const keyListener = (event) => {
-      if (keySet.has(event.key.toLowerCase()) || keySet.has(event.code.toLowerCase())) {
+      if (keySet.has(event.key?.toLowerCase() ?? "") || keySet.has(event.code?.toLowerCase() ?? "")) {
         messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
           key: event.key,
           code: event.code,
@@ -839,6 +865,50 @@ function createRuntimeNamespace(client) {
         counts[eventType] = handlers.size;
       }
       return counts;
+    },
+    cdn: {
+      url(pathOrStrings, ...values) {
+        const gameUrl = client["initPayload"]?.gameUrl;
+        let path;
+        if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
+          const strings = pathOrStrings;
+          path = strings.reduce((acc, str, i) => {
+            return acc + str + (values[i] != null ? String(values[i]) : "");
+          }, "");
+        } else {
+          path = pathOrStrings;
+        }
+        if (!gameUrl) {
+          return path.startsWith("./") ? path : "./" + path;
+        }
+        const cleanPath = path.startsWith("./") ? path.slice(2) : path;
+        return gameUrl + cleanPath;
+      },
+      fetch: async (path, options) => {
+        const gameUrl = client["initPayload"]?.gameUrl;
+        if (!gameUrl) {
+          const relativePath = path.startsWith("./") ? path : "./" + path;
+          return fetch(relativePath, options);
+        }
+        const cleanPath = path.startsWith("./") ? path.slice(2) : path;
+        return fetch(gameUrl + cleanPath, options);
+      },
+      json: async (path) => {
+        const response = await client.runtime.cdn.fetch(path);
+        return response.json();
+      },
+      blob: async (path) => {
+        const response = await client.runtime.cdn.fetch(path);
+        return response.blob();
+      },
+      text: async (path) => {
+        const response = await client.runtime.cdn.fetch(path);
+        return response.text();
+      },
+      arrayBuffer: async (path) => {
+        const response = await client.runtime.cdn.fetch(path);
+        return response.arrayBuffer();
+      }
     }
   };
 }
@@ -1003,8 +1073,8 @@ async function request({
   const rawText = await res.text().catch(() => "");
   return rawText && rawText.length > 0 ? rawText : undefined;
 }
-async function fetchManifest(assetBundleBase) {
-  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
+async function fetchManifest(deploymentUrl) {
+  const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
   try {
     const response = await fetch(manifestUrl);
     if (!response.ok) {
@@ -1042,8 +1112,8 @@ function createGamesNamespace(client) {
       const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
       return gameFetchCache.get(gameIdOrSlug, async () => {
         const baseGameData = await promise;
-        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null && baseGameData.assetBundleBase !== "") {
-          const manifestData = await fetchManifest(baseGameData.assetBundleBase);
+        if (baseGameData.gameType === "hosted" && baseGameData.deploymentUrl !== null && baseGameData.deploymentUrl !== "") {
+          const manifestData = await fetchManifest(baseGameData.deploymentUrl);
           return { ...baseGameData, manifest: manifestData };
         }
         return baseGameData;
@@ -1232,22 +1302,28 @@ function createDevNamespace(client) {
       }
     },
     games: {
-      deploy: {
-        frontend: async (slug, metadata, file, hooks) => {
-          hooks?.onEvent?.({ type: "init" });
-          const game = await client["request"](`/games/${slug}`, "PUT", {
+      deploy: async (slug, options) => {
+        const { metadata, file, backend, hooks } = options;
+        hooks?.onEvent?.({ type: "init" });
+        let game;
+        if (metadata) {
+          game = await client["request"](`/games/${slug}`, "PUT", {
             body: metadata
           });
-          if (metadata.gameType === "external" || file === null) {
+          if (metadata.gameType === "external" && !file && !backend) {
             return game;
           }
+        }
+        let uploadToken;
+        if (file) {
           const fileName = file instanceof File ? file.name : "game.zip";
           const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
             body: {
               fileName,
-              gameId: game.id
+              gameId: game?.id || slug
             }
           });
+          uploadToken = initiateResponse.uploadToken;
           if (hooks?.onEvent && typeof XMLHttpRequest !== "undefined") {
             await new Promise((resolve, reject) => {
               const xhr = new XMLHttpRequest;
@@ -1288,7 +1364,9 @@ function createDevNamespace(client) {
               throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
             }
           }
-          const finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
+        }
+        if (uploadToken || backend) {
+          const deployUrl = `${client.baseUrl}/games/${slug}/deploy`;
           const authToken = client.getToken();
           const tokenType = client.getTokenType();
           const headers = {
@@ -1301,25 +1379,33 @@ function createDevNamespace(client) {
               headers["Authorization"] = `Bearer ${authToken}`;
             }
           }
-          const finalizeResponse = await fetch(finalizeUrl, {
+          const requestBody = {};
+          if (uploadToken)
+            requestBody.uploadToken = uploadToken;
+          if (metadata)
+            requestBody.metadata = metadata;
+          if (backend) {
+            requestBody.code = backend.code;
+            requestBody.config = backend.config;
+            if (backend.bindings)
+              requestBody.bindings = backend.bindings;
+            if (backend.schema)
+              requestBody.schema = backend.schema;
+            if (backend.secrets)
+              requestBody.secrets = backend.secrets;
+          }
+          const finalizeResponse = await fetch(deployUrl, {
             method: "POST",
             headers,
-            body: JSON.stringify({
-              tempS3Key: initiateResponse.tempS3Key,
-              gameId: initiateResponse.gameId,
-              version: initiateResponse.version,
-              slug,
-              metadata,
-              originalFileName: fileName
-            }),
+            body: JSON.stringify(requestBody),
             credentials: "omit"
           });
           if (!finalizeResponse.ok) {
             const errText = await finalizeResponse.text().catch(() => "");
-            throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
+            throw new Error(`Deploy request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
           }
           if (!finalizeResponse.body) {
-            throw new Error("Finalize response body missing");
+            throw new Error("Deploy response body missing");
           }
           hooks?.onEvent?.({ type: "finalizeStart" });
           let sawAnyServerEvent = false;
@@ -1374,20 +1460,19 @@ function createDevNamespace(client) {
               }
             }
           }
-          throw new Error("Upload completed but no final game data received");
-        },
-        backend: async (slug, bundle) => {
-          return client["request"](`/games/${slug}/backend/deploy`, "POST", { body: bundle });
-        },
-        seed: async (slug, code, environment) => {
-          return client["request"](`/games/${slug}/seed`, "POST", {
-            body: { code, environment }
-          });
+          throw new Error("Deployment completed but no final game data received");
         }
+        if (game) {
+          return game;
+        }
+        throw new Error("No deployment actions specified (need metadata, file, or backend)");
       },
-      upsert: async (slug, metadata) => {
-        return client.dev.games.deploy.frontend(slug, metadata, null);
+      seed: async (slug, code, environment) => {
+        return client["request"](`/games/${slug}/seed`, "POST", {
+          body: { code, environment }
+        });
       },
+      upsert: async (slug, metadata) => client["request"](`/games/${slug}`, "PUT", { body: metadata }),
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE"),
       secrets: {
         set: async (slug, secrets) => {
@@ -1444,6 +1529,24 @@ function createDevNamespace(client) {
         delete: async (slug, key) => {
           await client["request"](`/games/${slug}/bucket/${encodeURIComponent(key)}`, "DELETE");
         }
+      },
+      domains: {
+        add: async (slug, hostname) => {
+          return client["request"](`/games/${slug}/domains`, "POST", {
+            body: { hostname }
+          });
+        },
+        list: async (slug) => {
+          const result = await client["request"](`/games/${slug}/domains`, "GET");
+          return result.domains;
+        },
+        status: async (slug, hostname, refresh) => {
+          const params = refresh ? "?refresh=true" : "";
+          return client["request"](`/games/${slug}/domains/${hostname}${params}`, "GET");
+        },
+        delete: async (slug, hostname) => {
+          await client["request"](`/games/${slug}/domains/${hostname}`, "DELETE");
+        }
       }
     },
     items: {
@@ -2493,7 +2596,7 @@ function createStandaloneConfig() {
   console.warn("[Playcademy SDK] Standalone mode detected, creating mock context for local development");
   const mockConfig = {
     baseUrl: "http://localhost:4321",
-    gameUrl: "http://localhost:8788",
+    gameUrl: window.location.origin,
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
     realtimeUrl: undefined
@@ -2738,9 +2841,13 @@ var init_client = __esm(() => {
 
 // src/index.ts
 init_client();
+init_errors();
 init_messaging();
 export {
   messaging,
+  extractApiErrorInfo,
+  PlaycademyError,
   PlaycademyClient,
-  MessageEvents
+  MessageEvents,
+  ApiError
 };

package/dist/server.d.ts

@@ -54,6 +54,8 @@ interface IntegrationsConfig {
     kv?: boolean;
     /** Bucket storage (optional) */
     bucket?: boolean;
+    /** Authentication (optional) */
+    auth?: boolean;
 }
 /**
  * Unified Playcademy configuration
@@ -371,4 +373,4 @@ declare function verifyGameToken(gameToken: string, options?: {
 }>;
 
 export { PlaycademyClient, verifyGameToken };
-export type { BackendDeploymentBundle, BackendResourceBindings, IntegrationsConfig, PlaycademyConfig, PlaycademyServerClientConfig, PlaycademyServerClientState, TimebackIntegrationConfig };
+export type { BackendDeploymentBundle, BackendResourceBindings, IntegrationsConfig, PlaycademyConfig, PlaycademyServerClientConfig, PlaycademyServerClientState, TimebackIntegrationConfig, UserInfo };