playcademy 0.3.0 → 0.5.0

package/dist/index.js

@@ -19867,6 +19867,11 @@ function getBaseUrl() {
   }
   return "https://hub.playcademy.com";
 }
+function getApiUrl(path3) {
+  const baseUrl = getBaseUrl();
+  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
+  return `${baseUrl}${normalizedPath}`;
+}
 function getProfileName() {
   const context2 = getCliContext();
   return context2.profile || process.env.PLAYCADEMY_PROFILE || "default";
@@ -20585,6 +20590,17 @@ async function deriveTimebackConfig(config) {
     componentResource
   };
 }
+function deriveSourcedIds(courseId) {
+  return {
+    organization: PLAYCADEMY_DEFAULTS.organization,
+    course: courseId,
+    component: `${courseId}-component`,
+    resource: `${courseId}-resource`,
+    componentResource: `${courseId}-cr`,
+    classCore: `${courseId}-class-core`,
+    classAfterHours: `${courseId}-class-after`
+  };
+}
 
 // src/lib/templates/loader.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
@@ -26044,6 +26060,15 @@ var init_achievements = () => {
 };
 function createTimebackNamespace(client) {
   return {
+    recordProgress: (progressData) => {
+      return client["request"]("/api/integrations/timeback/progress", "POST", { progressData }, void 0, true);
+    },
+    recordSessionEnd: (sessionData) => {
+      return client["request"]("/api/integrations/timeback/session-end", "POST", { sessionData }, void 0, true);
+    },
+    awardXP: (xpAmount, metadata) => {
+      return client["request"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata }, void 0, true);
+    },
     management: {
       setup: (request2) => {
         return client["request"]("/timeback/setup", "POST", request2);
@@ -26252,7 +26277,8 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
 function createStandaloneConfig() {
   console.warn("[Playcademy SDK] Standalone mode detected, creating mock context for local development");
   const mockConfig = {
-    baseUrl: "/api",
+    baseUrl: "http://localhost:4321",
+    gameUrl: "http://localhost:8788",
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
     realtimeUrl: void 0
@@ -26271,6 +26297,7 @@ async function init(options) {
   }
   const client = new PlaycademyClient2({
     baseUrl: config.baseUrl,
+    gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
     autoStartSession: window.self !== window.top
@@ -26340,6 +26367,7 @@ var init_client = __esm2(() => {
   init_static();
   PlaycademyClient = class PlaycademyClient {
     baseUrl;
+    gameUrl;
     authStrategy;
     gameId;
     config;
@@ -26348,7 +26376,8 @@ var init_client = __esm2(() => {
     authContext;
     initPayload;
     constructor(config) {
-      this.baseUrl = config?.baseUrl || "/api";
+      this.baseUrl = config?.baseUrl || "";
+      this.gameUrl = config?.gameUrl;
       this.gameId = config?.gameId;
       this.config = config || {};
       this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
@@ -26359,7 +26388,16 @@ var init_client = __esm2(() => {
     getBaseUrl() {
       const isRelative = this.baseUrl.startsWith("/");
       const isBrowser2 = typeof window !== "undefined";
-      return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+      const effectiveBaseUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+      return `${effectiveBaseUrl}/api`;
+    }
+    getGameBackendUrl() {
+      if (!this.gameUrl)
+        return this.getBaseUrl();
+      const isRelative = this.gameUrl.startsWith("/");
+      const isBrowser2 = typeof window !== "undefined";
+      const effectiveGameUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.gameUrl}` : this.gameUrl;
+      return `${effectiveGameUrl}/api`;
     }
     ping() {
       return "pong";
@@ -26392,16 +26430,17 @@ var init_client = __esm2(() => {
         listener(payload);
       });
     }
-    async request(path3, method, body, headers) {
+    async request(path3, method, body, headers, useGameBackend = false) {
       const effectiveHeaders = {
         ...headers,
         ...this.authStrategy.getHeaders()
       };
+      const targetBaseUrl = useGameBackend ? this.getGameBackendUrl() : this.baseUrl;
       return request({
         path: path3,
         method,
         body,
-        baseUrl: this.baseUrl,
+        baseUrl: targetBaseUrl,
         extraHeaders: effectiveHeaders
       });
     }
@@ -27299,6 +27338,13 @@ async function getBackendSize(config) {
     return null;
   }
 }
+async function getDeployedBackend(_client, _gameId) {
+  try {
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function deployGameBackend(client, slug, config, projectPath, previousBackendHash, fullConfig) {
   try {
     const hasCustomRoutes2 = hasLocalBackend(projectPath);
@@ -27512,6 +27558,8 @@ import { stat } from "node:fs/promises";
 import { join as join5 } from "node:path";
 
 // src/lib/deploy/prompts.ts
+var REQUIRED_FIELDS = ["displayName", "gameType", "buildPath", "externalUrl"];
+var OPTIONAL_FIELDS = ["description", "emoji"];
 function getMissingFields(config) {
   const missingDisplayName = !config.displayName;
   const missingGameType = !config.gameType && !config.buildPath && !config.externalUrl;
@@ -27531,6 +27579,9 @@ function getMissingFields(config) {
 function hasMandatoryFieldsMissing(missing) {
   return missing.displayName || missing.gameType || missing.buildPath || missing.externalUrl;
 }
+function hasOptionalFieldsMissing(missing) {
+  return missing.description || missing.emoji;
+}
 
 // src/lib/deploy/validate.ts
 import { existsSync as existsSync4 } from "fs";
@@ -27938,8 +27989,8 @@ async function analyzeChanges(context2) {
 async function calculateDeploymentPlan(context2, changes) {
   const { config, isNewDeployment, projectPath, deployBackend } = context2;
   if (isNewDeployment) {
-    const needsBackend2 = hasLocalBackend(projectPath) || !!context2.fullConfig?.integrations;
-    const shouldDeployBackend2 = deployBackend && needsBackend2;
+    const needsBackend3 = hasLocalBackend(projectPath) || !!context2.fullConfig?.integrations;
+    const shouldDeployBackend2 = deployBackend && needsBackend3;
     return {
       action: "deploy-new",
       gameType: config.gameType ?? "hosted",
@@ -27968,8 +28019,8 @@ async function calculateDeploymentPlan(context2, changes) {
     }
   }
   const shouldDeployFrontend = changes.build !== false || changes.config;
-  const needsBackend = hasLocalBackend(projectPath) || !!context2.fullConfig?.integrations;
-  const shouldDeployBackend = deployBackend && (changes.backend === true || needsBackend);
+  const needsBackend2 = hasLocalBackend(projectPath) || !!context2.fullConfig?.integrations;
+  const shouldDeployBackend = deployBackend && (changes.backend === true || needsBackend2);
   return {
     action: "update-existing",
     gameType: config.gameType ?? "hosted",
@@ -28138,6 +28189,9 @@ import { join as join8 } from "path";
 function hasCustomRoutes() {
   return existsSync7(join8(getWorkspace(), "api"));
 }
+function needsBackend(config) {
+  return !!config.integrations || hasCustomRoutes();
+}
 
 // src/lib/dev/display.ts
 function displayRegisteredRoutes(integrations, customRoutes = []) {
@@ -32137,9 +32191,9 @@ async function registerBuiltinRoutes(app, integrations) {
 
 // src/lib/dev/server.ts
 async function startDevServer(port, config, options = {}) {
-  const { logger: enableLogger = true } = options;
+  const { logger: enableLogger = true, quiet = false } = options;
   const app = new Hono2();
-  if (enableLogger) {
+  if (enableLogger && !quiet) {
     app.use("*", logger2());
   }
   app.use("*", cors());
@@ -34325,6 +34379,103 @@ program.parse();
 if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
+export {
+  ConfigError,
+  OPTIONAL_FIELDS,
+  REQUIRED_FIELDS,
+  analyzeChanges,
+  bundleBackend,
+  calculateConfigDiff,
+  calculateDeploymentPlan,
+  confirmDeploymentPlan,
+  createClient,
+  deployBackendIfNeeded,
+  deployExternalGame,
+  deployGameBackend,
+  deployHostedGameFrontend,
+  deriveSourcedIds,
+  deriveTimebackConfig,
+  detectConfigChanges,
+  discoverRoutes,
+  displayCleanupWarning,
+  displayConfigPreview,
+  displayConfigSuccess,
+  displayCurrentConfiguration,
+  displayDeploymentDiff,
+  displayIntegrationDetails,
+  displayRegisteredRoutes,
+  displayResourcesStatus,
+  displaySuccessMessage,
+  ensureGameExists,
+  findConfigPath,
+  generateEntryCode,
+  generateJsConfig,
+  generateJsonConfig,
+  getApiUrl,
+  getAuthPath,
+  getBackendHash,
+  getBackendSize,
+  getBaseUrl,
+  getCallbackUrl,
+  getCliContext,
+  getCurrentProfile,
+  getDeployedBackend,
+  getDeployedGame,
+  getEnvironment,
+  getGameFromConfig,
+  getGamesStorePath,
+  getIntegrationsHash,
+  getMissingFields,
+  getProfile,
+  getProfileName,
+  getWebBaseUrl,
+  getWorkspace,
+  hasBackendChanged,
+  hasCustomRoutes,
+  hasLocalBackend,
+  hasMandatoryFieldsMissing,
+  hasOptionalFieldsMissing,
+  hashDirectory,
+  hashFile,
+  listProfiles,
+  loadAuthStore,
+  loadConfig,
+  loadDeployConfig,
+  loadGameStore,
+  logger,
+  needsBackend,
+  prepareDeploymentContext,
+  processConfigVariables,
+  promptForApiRoutes,
+  promptForGameInfo,
+  promptForMissingConfig,
+  promptForTimeBackIntegration,
+  registerCustomRoutes,
+  removeDeployedGame,
+  removeProfile,
+  reportCancellation,
+  reportDeploymentSuccess,
+  reportDryRun,
+  reportNoChanges,
+  requireAuthenticatedClient,
+  saveAuthStore,
+  saveDeployedGame,
+  saveDeploymentState,
+  saveGameStore,
+  saveProfile,
+  scaffoldApiDirectory,
+  selectConfigFormat,
+  selectEnvironment,
+  setCliContext,
+  startCallbackServer,
+  startDevServer,
+  startHotReload,
+  validateApiDirectoryDoesNotExist,
+  validateBuildPath,
+  validateConfig,
+  validateDeployConfig,
+  validateExternalUrl
+};
 /*! Bundled license information:
 
 chokidar/esm/index.js: