@playcademy/sdk 0.2.2 → 0.2.4

package/dist/internal.js

@@ -241,6 +241,7 @@ var detectOutputFormat = () => {
 };
 var colors = {
   reset: "\x1B[0m",
+  bold: "\x1B[1m",
   dim: "\x1B[2m",
   red: "\x1B[31m",
   yellow: "\x1B[33m",
@@ -262,44 +263,48 @@ var getLevelColor = (level) => {
       return colors.reset;
   }
 };
-var formatBrowserOutput = (level, message, context) => {
+var formatBrowserOutput = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const levelUpper = level.toUpperCase();
   const consoleMethod = getConsoleMethod(level);
+  const scopePrefix = scope ? `[${scope}] ` : "";
   if (context && Object.keys(context).length > 0) {
-    consoleMethod(`[${timestamp}] ${levelUpper}`, message, context);
+    consoleMethod(`[${timestamp}] ${levelUpper}`, `${scopePrefix}${message}`, context);
   } else {
-    consoleMethod(`[${timestamp}] ${levelUpper}`, message);
+    consoleMethod(`[${timestamp}] ${levelUpper}`, `${scopePrefix}${message}`);
   }
 };
-var formatColorTTY = (level, message, context) => {
+var formatColorTTY = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const levelColor = getLevelColor(level);
   const levelUpper = level.toUpperCase().padEnd(5);
   const consoleMethod = getConsoleMethod(level);
   const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+  const scopePrefix = scope ? `${colors.bold}[${scope}]${colors.reset} ` : "";
   if (context && Object.keys(context).length > 0) {
-    consoleMethod(`${coloredPrefix} ${message}`, context);
+    consoleMethod(`${coloredPrefix} ${scopePrefix}${message}`, context);
   } else {
-    consoleMethod(`${coloredPrefix} ${message}`);
+    consoleMethod(`${coloredPrefix} ${scopePrefix}${message}`);
   }
 };
-var formatJSONSingleLine = (level, message, context) => {
+var formatJSONSingleLine = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
     level: level.toUpperCase(),
+    ...scope && { scope },
     message,
     ...context && Object.keys(context).length > 0 && { context }
   };
   const consoleMethod = getConsoleMethod(level);
   consoleMethod(JSON.stringify(logEntry));
 };
-var formatJSONPretty = (level, message, context) => {
+var formatJSONPretty = (level, message, context, scope) => {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
     level: level.toUpperCase(),
+    ...scope && { scope },
     message,
     ...context && Object.keys(context).length > 0 && { context }
   };
@@ -340,36 +345,37 @@ var shouldLog = (level) => {
   return levelPriority[level] >= levelPriority[minLevel];
 };
 var customHandler;
-var performLog = (level, message, context) => {
+var performLog = (level, message, context, scope) => {
   if (!shouldLog(level))
     return;
   if (customHandler) {
-    customHandler(level, message, context);
+    customHandler(level, message, context, scope);
     return;
   }
   const outputFormat = detectOutputFormat();
   switch (outputFormat) {
     case "browser":
-      formatBrowserOutput(level, message, context);
+      formatBrowserOutput(level, message, context, scope);
       break;
     case "color-tty":
-      formatColorTTY(level, message, context);
+      formatColorTTY(level, message, context, scope);
       break;
     case "json-single-line":
-      formatJSONSingleLine(level, message, context);
+      formatJSONSingleLine(level, message, context, scope);
       break;
     case "json-pretty":
-      formatJSONPretty(level, message, context);
+      formatJSONPretty(level, message, context, scope);
       break;
   }
 };
-var createLogger = () => {
+var createLogger = (scopeName) => {
   return {
-    debug: (message, context) => performLog("debug", message, context),
-    info: (message, context) => performLog("info", message, context),
-    warn: (message, context) => performLog("warn", message, context),
-    error: (message, context) => performLog("error", message, context),
-    log: performLog
+    debug: (message, context) => performLog("debug", message, context, scopeName),
+    info: (message, context) => performLog("info", message, context, scopeName),
+    warn: (message, context) => performLog("warn", message, context, scopeName),
+    error: (message, context) => performLog("error", message, context, scopeName),
+    log: (level, message, context) => performLog(level, message, context, scopeName),
+    scope: (name) => createLogger(scopeName ? `${scopeName}.${name}` : name)
   };
 };
 var log = createLogger();
@@ -384,26 +390,87 @@ class PlaycademyError extends Error {
 
 class ApiError extends Error {
   status;
+  code;
   details;
-  constructor(status, message, details) {
-    super(`${status} ${message}`);
+  rawBody;
+  constructor(status, code, message, details, rawBody) {
+    super(message);
     this.status = status;
+    this.name = "ApiError";
+    this.code = code;
     this.details = details;
+    this.rawBody = rawBody;
     Object.setPrototypeOf(this, ApiError.prototype);
   }
+  static fromResponse(status, statusText, body) {
+    if (body && typeof body === "object" && "error" in body) {
+      const errorBody = body;
+      const err = errorBody.error;
+      if (err && typeof err === "object") {
+        return new ApiError(status, err.code ?? statusCodeToErrorCode(status), err.message ?? statusText, err.details, body);
+      }
+    }
+    return new ApiError(status, statusCodeToErrorCode(status), statusText, undefined, body);
+  }
+  is(code) {
+    return this.code === code;
+  }
+  isClientError() {
+    return this.status >= 400 && this.status < 500;
+  }
+  isServerError() {
+    return this.status >= 500;
+  }
+  isRetryable() {
+    return this.isServerError() || this.code === "TOO_MANY_REQUESTS" || this.code === "RATE_LIMITED" || this.code === "TIMEOUT";
+  }
+}
+function statusCodeToErrorCode(status) {
+  switch (status) {
+    case 400:
+      return "BAD_REQUEST";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 405:
+      return "METHOD_NOT_ALLOWED";
+    case 409:
+      return "CONFLICT";
+    case 410:
+      return "GONE";
+    case 412:
+      return "PRECONDITION_FAILED";
+    case 413:
+      return "PAYLOAD_TOO_LARGE";
+    case 422:
+      return "VALIDATION_FAILED";
+    case 429:
+      return "TOO_MANY_REQUESTS";
+    case 500:
+      return "INTERNAL_ERROR";
+    case 501:
+      return "NOT_IMPLEMENTED";
+    case 503:
+      return "SERVICE_UNAVAILABLE";
+    case 504:
+      return "TIMEOUT";
+    default:
+      return status >= 500 ? "INTERNAL_ERROR" : "BAD_REQUEST";
+  }
 }
 function extractApiErrorInfo(error) {
   if (!(error instanceof ApiError)) {
     return null;
   }
-  const info = {
+  return {
     status: error.status,
-    statusText: error.message
+    code: error.code,
+    message: error.message,
+    ...error.details !== undefined && { details: error.details }
   };
-  if (error.details) {
-    info.details = error.details;
-  }
-  return info;
 }
 
 // src/core/static/login.ts
@@ -1030,6 +1097,96 @@ function createUsersNamespace(client) {
     }
   };
 }
+// ../constants/src/achievements.ts
+var ACHIEVEMENT_IDS = {
+  PLAY_ANY_GAME_DAILY: "play_any_game_daily",
+  DAILY_CHEST_OPEN: "daily_chest_open",
+  LEADERBOARD_TOP3_DAILY: "leaderboard_top3_daily",
+  LEADERBOARD_TOP3_WEEKLY: "leaderboard_top3_weekly",
+  FIRST_SCORE_ANY_GAME: "first_score_any_game",
+  PERSONAL_BEST_ANY_GAME: "personal_best_any_game"
+};
+var ACHIEVEMENT_DEFINITIONS = [
+  {
+    id: ACHIEVEMENT_IDS.PLAY_ANY_GAME_DAILY,
+    title: "Play any game",
+    description: "Play any arcade game for at least 60 seconds in a single session.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "time_played_session",
+    completionConfig: { minSeconds: 60 },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.DAILY_CHEST_OPEN,
+    title: "Opened the daily chest",
+    description: "Find the chest on the map and open it to claim your reward.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "interaction",
+    completionConfig: { triggerId: "bunny_chest" },
+    target: { map: "arcade" },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_DAILY,
+    title: "Daily Champion",
+    description: "Finish in the top 3 of any game leaderboard for the day.",
+    scope: "daily",
+    rewardCredits: 25,
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [50, 30, 15]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_WEEKLY,
+    title: "Weekly Legend",
+    description: "Finish in the top 3 of any game leaderboard for the week.",
+    scope: "weekly",
+    rewardCredits: 50,
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [100, 60, 30]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.FIRST_SCORE_ANY_GAME,
+    title: "First Score",
+    description: "Submit your first score in any arcade game.",
+    scope: "game",
+    rewardCredits: 5,
+    limit: 1,
+    completionType: "first_score",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.PERSONAL_BEST_ANY_GAME,
+    title: "Personal Best",
+    description: "Beat your personal best score in any arcade game.",
+    scope: "daily",
+    rewardCredits: 5,
+    limit: 3,
+    completionType: "personal_best",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  }
+];
+// ../constants/src/typescript.ts
+var TSC_PACKAGE = "@typescript/native-preview";
+var USE_NATIVE_TSC = TSC_PACKAGE.includes("native-preview");
 // ../constants/src/overworld.ts
 var ITEM_SLUGS = {
   PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
@@ -1407,7 +1564,9 @@ function createAdminNamespace(client) {
       create: (props) => client["request"]("/currencies", "POST", { body: props }),
       get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
       list: () => client["request"]("/currencies", "GET"),
-      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", { body: props }),
+      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", {
+        body: props
+      }),
       delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
     },
     shopListings: {
@@ -1541,16 +1700,7 @@ function createDevNamespace(client) {
           let sawAnyServerEvent = false;
           const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
           let buffer = "";
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              if (!sawAnyServerEvent) {
-                hooks?.onClose?.();
-                hooks?.onEvent?.({ type: "close" });
-              }
-              break;
-            }
-            buffer += value;
+          const processBuffer = () => {
             let eolIndex;
             while ((eolIndex = buffer.indexOf(`
 
@@ -1583,19 +1733,34 @@ function createDevNamespace(client) {
                     break;
                   }
                   case "complete": {
+                    hooks?.onEvent?.({ type: "complete" });
                     reader.cancel();
                     return eventData;
                   }
                   case "error": {
                     reader.cancel();
-                    const status = typeof eventData.status === "number" ? eventData.status : 500;
-                    const message2 = eventData.message ?? "Deployment error";
-                    const details = eventData.details;
-                    throw new ApiError(status, message2, details);
+                    throw ApiError.fromResponse(eventData?.error?.status ?? 500, "Deployment error", eventData);
                   }
                 }
               }
             }
+            return null;
+          };
+          while (true) {
+            const { done, value } = await reader.read();
+            if (value) {
+              buffer += value;
+            }
+            const result = processBuffer();
+            if (result)
+              return result;
+            if (done) {
+              if (!sawAnyServerEvent) {
+                hooks?.onClose?.();
+                hooks?.onEvent?.({ type: "close" });
+              }
+              break;
+            }
           }
           throw new Error("Deployment completed but no final game data received");
         }
@@ -1644,16 +1809,11 @@ function createDevNamespace(client) {
         get: async (slug, key) => {
           const res = await client["request"](`/games/${slug}/bucket/${encodeURIComponent(key)}`, "GET", { raw: true });
           if (!res.ok) {
-            let errorMessage = res.statusText;
+            let errorBody;
             try {
-              const errorData = await res.json();
-              if (errorData.error) {
-                errorMessage = errorData.error;
-              } else if (errorData.message) {
-                errorMessage = errorData.message;
-              }
+              errorBody = await res.json();
             } catch {}
-            throw new Error(errorMessage);
+            throw ApiError.fromResponse(res.status, res.statusText, errorBody);
           }
           return res.arrayBuffer();
         },
@@ -1684,6 +1844,11 @@ function createDevNamespace(client) {
         delete: async (slug, hostname) => {
           await client["request"](`/games/${slug}/domains/${hostname}`, "DELETE");
         }
+      },
+      logs: {
+        getToken: async (slug, environment) => {
+          return client["request"](`/games/${slug}/logs/token`, "POST", { body: { environment } });
+        }
       }
     },
     items: {
@@ -1787,7 +1952,7 @@ async function request({
     const errorBody = await clonedRes.json().catch(() => clonedRes.text().catch(() => {
       return;
     })) ?? undefined;
-    throw new ApiError(res.status, res.statusText, errorBody);
+    throw ApiError.fromResponse(res.status, res.statusText, errorBody);
   }
   if (res.status === 204)
     return;
@@ -1841,7 +2006,7 @@ function createGamesNamespace(client) {
       const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
       return gameFetchCache.get(gameIdOrSlug, async () => {
         const baseGameData = await promise;
-        if (baseGameData.gameType === "hosted" && baseGameData.deploymentUrl !== null && baseGameData.deploymentUrl !== "") {
+        if (baseGameData.gameType === "hosted" && baseGameData.deploymentUrl !== null && baseGameData.deploymentUrl !== undefined && baseGameData.deploymentUrl !== "") {
           const manifestData = await fetchManifest(baseGameData.deploymentUrl);
           return { ...baseGameData, manifest: manifestData };
         }
@@ -1851,14 +2016,6 @@ function createGamesNamespace(client) {
     list: (options) => {
       return gamesListCache.get("all", () => client["request"]("/games", "GET"), options);
     },
-    saveState: async (state) => {
-      const gameId = client["_ensureGameId"]();
-      await client["request"](`/games/${gameId}/state`, "POST", { body: state });
-    },
-    loadState: async () => {
-      const gameId = client["_ensureGameId"]();
-      return client["request"](`/games/${gameId}/state`, "GET");
-    },
     startSession: async (gameId) => {
       const idToUse = gameId ?? client["_ensureGameId"]();
       return client["request"](`/games/${idToUse}/sessions`, "POST", {});
@@ -1914,7 +2071,9 @@ function createCharacterNamespace(client) {
       }
     },
     create: async (characterData) => {
-      return client["request"]("/character", "POST", { body: characterData });
+      return client["request"]("/character", "POST", {
+        body: characterData
+      });
     },
     update: async (updates) => {
       return client["request"]("/character", "PATCH", { body: updates });
@@ -1939,8 +2098,8 @@ function createCharacterNamespace(client) {
         return client["request"](`/character/accessories/${slot}`, "DELETE");
       },
       list: async () => {
-        const character = await client.character.get();
-        return character?.accessories || [];
+        const character2 = await client.character.get();
+        return character2?.accessories || [];
       }
     }
   };