playcademy 0.7.0 → 0.8.0

package/dist/index.js

@@ -2513,6 +2513,16 @@ var CONFIG_FILE_NAMES = [
   "playcademy.config.mjs"
 ];
 
+// src/constants/urls.ts
+var PLAYCADEMY_BASE_URLS = {
+  staging: "https://hub.dev.playcademy.net",
+  production: "https://hub.playcademy.com"
+};
+var GAME_BACKEND_DOMAINS = {
+  staging: "staging.playcademy.gg",
+  production: "playcademy.gg"
+};
+
 // src/lib/auth/storage.ts
 import { access, mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -2521,7 +2531,7 @@ import { join } from "node:path";
 // src/lib/core/context.ts
 var context = {};
 function setCliContext(ctx) {
-  context = ctx;
+  context = { ...context, ...ctx };
 }
 function getCliContext() {
   return context;
@@ -2531,26 +2541,47 @@ function getWorkspace() {
 }
 
 // src/lib/core/config.ts
+function normalizeEnvironment(env) {
+  if (!env) return null;
+  const normalized = env.toLowerCase().trim();
+  if (normalized === "staging" || normalized === "stage") {
+    return "staging";
+  }
+  if (normalized === "production" || normalized === "prod") {
+    return "production";
+  }
+  return null;
+}
+function ensureEnvironment(env, logger2) {
+  if (env) {
+    const normalized = normalizeEnvironment(env);
+    if (!normalized) {
+      logger2.newLine();
+      logger2.error(`Invalid environment: "${env}"`);
+      logger2.newLine();
+      logger2.info("Valid environments: staging, production");
+      logger2.newLine();
+      process.exit(1);
+    }
+    setCliContext({ environment: normalized });
+  }
+  return getEnvironment();
+}
 function getEnvironment() {
   const context2 = getCliContext();
   if (context2.environment) {
     return context2.environment;
   }
   const env = process.env.PLAYCADEMY_ENV?.toLowerCase();
-  if (env === "staging") {
-    return "staging";
+  if (env === "staging" || env === "production") {
+    return env;
   }
-  return "production";
+  return "staging";
 }
 function getBaseUrl() {
   const explicitUrl = process.env.PLAYCADEMY_BASE_URL;
-  if (explicitUrl) {
-    return explicitUrl;
-  }
-  if (getEnvironment() === "staging") {
-    return "https://hub.dev.playcademy.net";
-  }
-  return "https://hub.playcademy.com";
+  if (explicitUrl) return explicitUrl;
+  return PLAYCADEMY_BASE_URLS[getEnvironment()];
 }
 function getApiUrl(path) {
   const baseUrl = getBaseUrl();
@@ -2573,6 +2604,12 @@ async function ensureAuthDir() {
   const authDir = join(homedir(), ".playcademy");
   await mkdir(authDir, { recursive: true });
 }
+function createEmptyEnvironmentProfiles() {
+  return {
+    default: null,
+    profiles: {}
+  };
+}
 async function loadAuthStore() {
   try {
     await ensureAuthDir();
@@ -2583,8 +2620,8 @@ async function loadAuthStore() {
   } catch {
   }
   return {
-    default: null,
-    profiles: {}
+    staging: createEmptyEnvironmentProfiles(),
+    production: createEmptyEnvironmentProfiles()
   };
 }
 async function saveAuthStore(store) {
@@ -2601,45 +2638,79 @@ async function getCurrentProfile() {
     };
   }
   const store = await loadAuthStore();
+  const environment = getEnvironment();
   const profileName = getProfileName();
+  const envProfiles = store[environment];
+  if (!envProfiles) {
+    return null;
+  }
   if (profileName === "default") {
-    return store.default;
+    return envProfiles.default;
   }
-  return store.profiles[profileName] || null;
+  return envProfiles.profiles[profileName] || null;
 }
-async function saveProfile(profileName, profile) {
+async function saveProfile(environment, profileName, profile) {
   const store = await loadAuthStore();
+  if (!store[environment]) {
+    store[environment] = createEmptyEnvironmentProfiles();
+  }
+  const envProfiles = store[environment];
   if (profileName === "default") {
-    store.default = profile;
+    envProfiles.default = profile;
   } else {
-    store.profiles[profileName] = profile;
+    envProfiles.profiles[profileName] = profile;
   }
   await saveAuthStore(store);
 }
-async function removeProfile(profileName) {
+async function removeProfile(environment, profileName) {
   const store = await loadAuthStore();
+  if (!store[environment]) {
+    return;
+  }
+  const envProfiles = store[environment];
   if (profileName === "default") {
-    store.default = null;
+    envProfiles.default = null;
   } else {
-    delete store.profiles[profileName];
+    delete envProfiles.profiles[profileName];
   }
   await saveAuthStore(store);
 }
-async function getProfile(profileName) {
+async function getProfile(environment, profileName) {
   const store = await loadAuthStore();
+  const envProfiles = store[environment];
+  if (!envProfiles) {
+    return null;
+  }
   if (profileName === "default") {
-    return store.default;
+    return envProfiles.default;
   }
-  return store.profiles[profileName] || null;
+  return envProfiles.profiles[profileName] || null;
 }
 async function listProfiles() {
   const store = await loadAuthStore();
-  const profiles = [];
-  if (store.default) {
-    profiles.push("default");
-  }
-  profiles.push(...Object.keys(store.profiles));
-  return profiles;
+  const profileMap = /* @__PURE__ */ new Map();
+  const stagingProfiles = [];
+  if (store.staging.default) {
+    stagingProfiles.push("default");
+  }
+  stagingProfiles.push(...Object.keys(store.staging.profiles));
+  profileMap.set("staging", stagingProfiles);
+  const productionProfiles = [];
+  if (store.production.default) {
+    productionProfiles.push("default");
+  }
+  productionProfiles.push(...Object.keys(store.production.profiles));
+  profileMap.set("production", productionProfiles);
+  return profileMap;
+}
+async function getAuthenticatedEnvironments() {
+  const store = await loadAuthStore();
+  const environments = [];
+  const hasStaging = store.staging.default !== null || Object.keys(store.staging.profiles).length > 0;
+  const hasProduction = store.production.default !== null || Object.keys(store.production.profiles).length > 0;
+  if (hasStaging) environments.push("staging");
+  if (hasProduction) environments.push("production");
+  return environments;
 }
 
 // src/lib/auth/http-server/server.ts
@@ -7260,15 +7331,7 @@ function createDevNamespace(client) {
               throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
             }
           }
-          const baseUrl = (() => {
-            const anyClient = client;
-            try {
-              return typeof anyClient.getBaseUrl === "function" ? anyClient.getBaseUrl() : "/api";
-            } catch {
-              return "/api";
-            }
-          })();
-          const finalizeUrl = baseUrl.replace(/\/$/, "") + "/games/uploads/finalize/";
+          const finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
           const authToken = client.getToken();
           const tokenType = client.getTokenType();
           const headers = {
@@ -8746,13 +8809,13 @@ var init_achievements = () => {
 function createTimebackNamespace(client) {
   return {
     recordProgress: (progressData) => {
-      return client["request"]("/api/integrations/timeback/progress", "POST", { progressData }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/progress", "POST", { progressData });
     },
     recordSessionEnd: (sessionData) => {
-      return client["request"]("/api/integrations/timeback/session-end", "POST", { sessionData }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/session-end", "POST", { sessionData });
     },
     awardXP: (xpAmount, metadata) => {
-      return client["request"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata });
     },
     management: {
       setup: (request2) => {
@@ -9061,7 +9124,7 @@ var init_client = __esm2(() => {
     authContext;
     initPayload;
     constructor(config) {
-      this.baseUrl = config?.baseUrl || "";
+      this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
       this.gameUrl = config?.gameUrl;
       this.gameId = config?.gameId;
       this.config = config || {};
@@ -9077,8 +9140,9 @@ var init_client = __esm2(() => {
       return `${effectiveBaseUrl}/api`;
     }
     getGameBackendUrl() {
-      if (!this.gameUrl)
-        return this.getBaseUrl();
+      if (!this.gameUrl) {
+        throw new PlaycademyError("Game backend URL not configured. gameUrl must be set to use game backend features.");
+      }
       const isRelative = this.gameUrl.startsWith("/");
       const isBrowser2 = typeof window !== "undefined";
       const effectiveGameUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.gameUrl}` : this.gameUrl;
@@ -9115,17 +9179,29 @@ var init_client = __esm2(() => {
         listener(payload);
       });
     }
-    async request(path, method, body, headers, useGameBackend = false) {
+    async request(path, method, body, headers) {
       const effectiveHeaders = {
         ...headers,
         ...this.authStrategy.getHeaders()
       };
-      const targetBaseUrl = useGameBackend ? this.getGameBackendUrl() : this.baseUrl;
       return request({
         path,
         method,
         body,
-        baseUrl: targetBaseUrl,
+        baseUrl: this.baseUrl,
+        extraHeaders: effectiveHeaders
+      });
+    }
+    async requestGameBackend(path, method, body, headers) {
+      const effectiveHeaders = {
+        ...headers,
+        ...this.authStrategy.getHeaders()
+      };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.getGameBackendUrl(),
         extraHeaders: effectiveHeaders
       });
     }
@@ -9362,9 +9438,8 @@ var logger = {
 async function createClient() {
   const profile = await getCurrentProfile();
   const baseUrl = getBaseUrl();
-  const apiBaseUrl = `${baseUrl}/api`;
   const client = new PlaycademyClient({
-    baseUrl: apiBaseUrl,
+    baseUrl,
     token: profile?.token
   });
   if (profile?.token && profile?.tokenType) {
@@ -9374,11 +9449,12 @@ async function createClient() {
 }
 async function requireAuthenticatedClient() {
   const profile = await getCurrentProfile();
+  const environment = getEnvironment();
   if (!profile) {
     logger.newLine();
     logger.admonition("warning", "Login Required", [
-      "You need to be logged in to run this command.",
-      "Run `playcademy login` to authenticate."
+      `You are not logged into ${environment}.`,
+      environment === "production" ? `Run \`playcademy login --env ${environment}\` to authenticate.` : "Run `playcademy login` to authenticate."
     ]);
     logger.newLine();
     process.exit(1);
@@ -10238,16 +10314,25 @@ async function validateDeployConfig(config) {
 // src/lib/deploy/interaction.ts
 async function selectEnvironment(options) {
   let environment = options.env;
-  const shouldPrompt = !environment && !options.dryRun && !process.env.PLAYCADEMY_ENV && !process.env.PLAYCADEMY_BASE_URL;
-  if (shouldPrompt) {
+  if (environment || process.env.PLAYCADEMY_ENV || process.env.PLAYCADEMY_BASE_URL) {
+    if (environment) {
+      setCliContext({ environment });
+    }
+    return;
+  }
+  const authenticatedEnvs = await getAuthenticatedEnvironments();
+  if (authenticatedEnvs.length === 1) {
+    environment = authenticatedEnvs[0];
+    logger.info(`Deploying to ${environment}`, 1);
+  } else if (authenticatedEnvs.length === 2 && !options.dryRun) {
     logger.newLine();
     environment = await select({
       message: "Select deployment environment:",
       choices: [
-        { value: "production", name: "Production (hub.playcademy.com)" },
-        { value: "staging", name: "Staging (hub.dev.playcademy.net)" }
+        { value: "staging", name: "Staging (hub.dev.playcademy.net)" },
+        { value: "production", name: "Production (hub.playcademy.com)" }
       ],
-      default: "production"
+      default: "staging"
     });
   }
   if (environment) {
@@ -10395,10 +10480,12 @@ function displayCurrentConfiguration(context2) {
   } else if (config.externalUrl) {
     logger.data("URL", config.externalUrl, 1);
   }
-  if (existingGame) {
+  if (context2.isGameDeployed) {
     logger.data("Status", "Deployed", 1);
-  } else {
+  } else if (existingGame) {
     logger.data("Status", "Not deployed", 1);
+  } else {
+    logger.data("Status", "New deployment", 1);
   }
   logger.newLine();
 }
@@ -10427,14 +10514,15 @@ async function reportNoChanges(context2) {
 function reportDeploymentSuccess(result, context2) {
   const { game, backendDeployment } = result;
   const { client, previousBackendHash } = context2;
-  const action = context2.isNewDeployment ? "deployed" : "updated";
+  const action = context2.isGameDeployed ? "updated" : "deployed";
   logger.newLine();
   logger.success(`${game.displayName} ${action} successfully!`);
   logger.newLine();
   const baseUrl = getWebBaseUrl(client.getBaseUrl());
   logger.data("Game URL", underline(blueBright(`${baseUrl}/g/${game.slug}`)), 1);
   if (backendDeployment || previousBackendHash) {
-    const backendUrl = `https://${game.slug}.playcademy.gg/api`;
+    const gameDomain = GAME_BACKEND_DOMAINS[getEnvironment()];
+    const backendUrl = `https://${game.slug}.${gameDomain}/api`;
     logger.data("Backend API", underline(blueBright(backendUrl)), 1);
   }
   if (game.version !== "external") {
@@ -10458,10 +10546,10 @@ import { stat as stat2 } from "node:fs/promises";
 
 // ../data/src/domains/game/helpers.ts
 var isHostedGame = (game) => {
-  return game.gameType === "hosted" && game.assetBundleBase !== null;
+  return game.gameType === "hosted" && !!game.assetBundleBase;
 };
 var isExternalGame = (game) => {
-  return game.gameType === "external" && game.externalUrl !== null;
+  return game.gameType === "external" && !!game.externalUrl;
 };
 function isGameDeployed(game) {
   return isHostedGame(game) || isExternalGame(game);
@@ -10527,9 +10615,9 @@ async function prepareDeploymentContext(options) {
     configFileName,
     client,
     projectPath,
-    existingGame: gameIsDeployed ? existingGame : void 0,
+    existingGame,
     deployedGameInfo: deployedGameInfo ?? void 0,
-    isNewDeployment: !gameIsDeployed,
+    isGameDeployed: gameIsDeployed,
     buildHash,
     buildSize,
     previousBuildHash: deployedGameInfo?.buildHash,
@@ -10579,8 +10667,8 @@ async function analyzeChanges(context2) {
   };
 }
 async function calculateDeploymentPlan(context2, changes) {
-  const { config, isNewDeployment, projectPath, deployBackend } = context2;
-  if (isNewDeployment) {
+  const { config, isGameDeployed: isGameDeployed2, projectPath, deployBackend } = context2;
+  if (!isGameDeployed2) {
     const needsBackend3 = hasLocalBackend(projectPath) || !!context2.fullConfig?.integrations;
     const shouldDeployBackend2 = deployBackend && needsBackend3;
     return {
@@ -11435,19 +11523,28 @@ initCommand.addCommand(configCommand);
 
 // src/commands/login.ts
 import { input as input4, password, select as select3 } from "@inquirer/prompts";
+import { bold as bold4, dim as dim6, whiteBright } from "colorette";
 import { Command as Command4 } from "commander";
 import open from "open";
 init_file_loader();
-var loginCommand = new Command4("login").description("Authenticate with Playcademy").option("-e, --email <email>", "Email address (for email/password auth)").option("-p, --password <password>", "Password (for email/password auth)").option("--sso", "Use Timeback SSO authentication").action(async (options) => {
-  const { email, password: password2, sso } = options;
-  logger.newLine();
+var loginCommand = new Command4("login").description("Authenticate with Playcademy").option("-e, --email <email>", "Email address (for email/password auth)").option("-p, --password <password>", "Password (for email/password auth)").option("--sso", "Use Timeback SSO authentication").option("--env <environment>", "Environment to login to (staging or production)").action(async (options) => {
+  const { email, password: password2, sso, env } = options;
+  const environment = ensureEnvironment(env, logger);
   const profileName = getProfileName();
-  const existingProfile = await getProfile(profileName);
+  logger.newLine();
+  const existingProfile = await getProfile(environment, profileName);
   if (existingProfile) {
-    const email2 = existingProfile.email;
-    logger.info(
-      `Already logged in to profile "${profileName}"` + (email2 ? ` as ${email2}` : "")
-    );
+    const email2 = existingProfile.email || "unknown user";
+    const otherEnv = environment === "staging" ? "production" : "staging";
+    const otherProfile = await getProfile(otherEnv, profileName);
+    logger.admonition("note", "I know you!", [
+      "You are already logged in",
+      "",
+      dim6("Email: ") + bold4(email2),
+      dim6("Environment: ") + bold4(environment),
+      dim6("Profile: ") + bold4(profileName),
+      ...otherProfile ? [dim6("Other Profile: ") + bold4(otherEnv)] : []
+    ]);
     logger.newLine();
     return;
   }
@@ -11462,7 +11559,7 @@ var loginCommand = new Command4("login").description("Authenticate with Playcade
   });
   logger.newLine();
   if (authMethod === "sso") {
-    await handleSsoLogin(profileName);
+    await handleSsoLogin(environment, profileName);
     return;
   }
   const finalEmail = email || await promptForEmail();
@@ -11515,14 +11612,17 @@ var loginCommand = new Command4("login").description("Authenticate with Playcade
     logger.newLine();
     await runStep(
       `Saving credentials to profile "${profileName}"`,
-      () => saveProfile(profileName, authProfile),
+      () => saveProfile(environment, profileName, authProfile),
       "Credentials saved successfully"
     );
-    logger.success(`Logged in as ${authProfile.email}`);
-    if (profileName !== "default") {
-      logger.newLine();
-      logger.info(`Profile saved as "${profileName}"`);
-    }
+    logger.newLine();
+    logger.admonition("tip", "Logged In Successfully!", [
+      `Email: ${authProfile.email}`,
+      `Environment: ${environment}`,
+      ...profileName !== "default" ? [`Profile: ${profileName}`] : [],
+      "",
+      ...profileName !== "default" ? [`Use \`--profile ${profileName}\` with commands to use this profile`] : []
+    ]);
     logger.newLine();
   } catch (error) {
     logger.newLine();
@@ -11533,7 +11633,7 @@ var loginCommand = new Command4("login").description("Authenticate with Playcade
     process.exit(1);
   }
 });
-async function handleSsoLogin(profileName) {
+async function handleSsoLogin(environment, profileName) {
   try {
     const serverPromise = startCallbackServer(SSO_AUTH_TIMEOUT_MS);
     const baseUrl = getBaseUrl();
@@ -11578,21 +11678,20 @@ async function handleSsoLogin(profileName) {
       email: result.data.email
     };
     logger.newLine();
-    logger.admonition("warning", "Your API Key", [apiKeyResult.apiKey]);
-    logger.warn("Save this key securely - it will not be shown again!", 1);
+    logger.admonition("warning", "Your API Key", [
+      "",
+      whiteBright(bold4(apiKeyResult.apiKey)),
+      "",
+      "Save this key securely - it will not be shown again!"
+    ]);
     logger.newLine();
     await runStep(
       `Saving credentials to profile "${profileName}"`,
-      () => saveProfile(profileName, authProfile),
-      "Credentials saved successfully"
+      () => saveProfile(environment, profileName, authProfile),
+      "Credentials saved successfully",
+      { silent: true }
     );
-    logger.success(`Logged in as ${authProfile.email}`);
-    if (profileName !== "default") {
-      logger.newLine();
-      logger.info(`Profile saved as "${profileName}"`);
-      logger.newLine();
-      logger.aside(`Use \`--profile ${profileName}\` with commands to use this profile`, 1);
-    }
+    logger.success(`Logged in to ${environment} as ${authProfile.email}`);
     logger.newLine();
   } catch (error) {
     logger.newLine();
@@ -11631,27 +11730,23 @@ async function promptForPassword() {
 
 // src/commands/logout.ts
 import { Command as Command5 } from "commander";
-var logoutCommand = new Command5("logout").description("Log out from Playcademy").option("--profile <name>", "Profile to log out from", "default").action(async (options) => {
-  const { profile: profileName } = options;
+var logoutCommand = new Command5("logout").description("Log out from Playcademy").argument("[profile]", "Profile name to logout from", "default").option("--env <environment>", "Environment to logout from (staging or production)").action(async (profileName, options) => {
+  const { env } = options;
+  const environment = ensureEnvironment(env, logger);
   try {
     logger.newLine();
-    const profile = await getProfile(profileName);
+    const profile = await getProfile(environment, profileName);
     if (!profile) {
-      logger.error(`Profile "${profileName}" not found`);
+      logger.error(`Profile "${profileName}" not found in ${environment}`);
+      logger.newLine();
       logger.info("Use `playcademy profiles list` to see available profiles");
       logger.newLine();
       process.exit(1);
     }
-    await removeProfile(profileName);
-    logger.success(`Logged out from profile "${profileName}"`);
-    if (profile.email) {
-      logger.info(`Previously logged in as: ${profile.email}`);
-    }
-    if (profileName === "default") {
-      logger.info("To log in again: playcademy login");
-    } else {
-      logger.info(`To log in again: playcademy login --profile ${profileName}`);
-    }
+    await removeProfile(environment, profileName);
+    logger.success(
+      `Logged out from ${environment} profile "${profileName}" (${profile.email})`
+    );
     logger.newLine();
   } catch (error) {
     logger.newLine();
@@ -11665,18 +11760,24 @@ var logoutCommand = new Command5("logout").description("Log out from Playcademy"
 
 // src/commands/me.ts
 import { Command as Command6 } from "commander";
-var meCommand = new Command6("me").description("Display current user information").action(async () => {
+var meCommand = new Command6("me").description("Display current user information").option(
+  "--env <environment>",
+  "Environment to check user information from (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
     logger.newLine();
     const user = await runStep(
-      "Fetching user information",
+      `Fetching user information from ${environment}`,
       client.users.me,
       "User information retrieved"
     );
     logger.newLine();
     logger.data("ID", user.id, 1);
     logger.data("Email", user.email, 1);
+    logger.data("Environment", environment, 1);
     if (user.username) {
       logger.data("Username", user.username, 1);
     }
@@ -11724,7 +11825,8 @@ async function executeDeployment(plan, context2) {
   return { game, backendDeployment };
 }
 async function runDeployment(options) {
-  await selectEnvironment(options);
+  const environment = ensureEnvironment(options.env, logger);
+  await selectEnvironment({ env: environment, dryRun: options.dryRun });
   const context2 = await prepareDeploymentContext(options);
   displayCurrentConfiguration(context2);
   const didPrompt = await promptForMissingConfig(context2);
@@ -11789,17 +11891,19 @@ import { Command as Command10 } from "commander";
 // src/commands/games/delete.ts
 import { confirm as confirm5, input as input5, select as select4 } from "@inquirer/prompts";
 import { Command as Command8 } from "commander";
-var deleteCommand = new Command8("delete").alias("rm").alias("remove").description("Delete a game").argument("[slug]", "Game slug to delete").option("-f, --force", "Skip confirmation prompt").action(async (slug, options) => {
+var deleteCommand = new Command8("delete").alias("rm").alias("remove").description("Delete a game").argument("[slug]", "Game slug to delete").option("-f, --force", "Skip confirmation prompt").option("--env <environment>", "Environment to delete game from (staging or production)").action(async (slug, options) => {
+  const { env } = options;
   try {
-    logger.newLine();
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
+    logger.newLine();
     const games2 = await runStep(
-      "Fetching games",
+      `Fetching games from ${environment}`,
       client.games.list,
-      (games3) => `Found ${games3.length} game${games3.length === 1 ? "" : "s"}`
+      (games3) => `Found ${games3.length} game${games3.length === 1 ? "" : "s"} in ${environment}`
     );
     if (games2.length === 0) {
-      logger.info("No games found");
+      logger.info(`No games found in ${environment}`);
       return;
     }
     logger.newLine();
@@ -11847,11 +11951,11 @@ var deleteCommand = new Command8("delete").alias("rm").alias("remove").descripti
       logger.newLine();
     }
     await runStep(
-      "Deleting game",
+      `Deleting game from ${environment}`,
       async () => {
         await client.dev.games.delete(game.id);
       },
-      "Game deleted successfully"
+      `Game deleted successfully from ${environment}`
     );
     const deployedGame = await getDeployedGame(getWorkspace());
     if (deployedGame && deployedGame.gameId === game.id) {
@@ -11870,14 +11974,16 @@ var deleteCommand = new Command8("delete").alias("rm").alias("remove").descripti
 
 // src/commands/games/list.ts
 import { Command as Command9 } from "commander";
-var listCommand = new Command9("list").alias("ls").description("List all games").action(async () => {
+var listCommand = new Command9("list").alias("ls").description("List all games").option("--env <environment>", "Environment to list games from (staging or production)").action(async (options) => {
+  const { env } = options;
   try {
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
     logger.newLine();
     const games2 = await runStep(
-      "Fetching games",
+      `Fetching games from ${environment}`,
       client.games.list,
-      (games3) => `Found ${games3.length} game${games3.length === 1 ? "" : "s"}`
+      (games3) => `Found ${games3.length} game${games3.length === 1 ? "" : "s"} in ${environment}`
     );
     if (games2.length === 0) {
       logger.info("No games found");
@@ -11916,22 +12022,30 @@ import { Command as Command13 } from "commander";
 
 // src/commands/dev/apply.ts
 import { Command as Command11 } from "commander";
-var applyCommand = new Command11("apply").description("Apply for developer status").action(async () => {
+var applyCommand = new Command11("apply").description("Apply for developer status").option(
+  "--env <environment>",
+  "Environment to apply for developer status in (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
-    logger.newLine();
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
+    logger.newLine();
     const currentStatus = await runStep(
-      "Checking current developer status",
+      `Checking current developer status in ${environment}`,
       client.dev.status.get,
-      "Current status retrieved"
+      `Current status retrieved from ${environment}`
     );
+    logger.newLine();
     if (currentStatus === "approved") {
-      logger.success("You are already an approved developer!");
+      logger.admonition("note", "Approved!", ["You are already an approved developer!"]);
       logger.newLine();
       return;
     }
     if (currentStatus === "pending") {
-      logger.info("Your developer application is pending review");
+      logger.admonition("warning", "Developer Status", [
+        "Your developer application is pending review"
+      ]);
       logger.newLine();
       return;
     }
@@ -11941,14 +12055,15 @@ var applyCommand = new Command11("apply").description("Apply for developer statu
       "Developer application submitted successfully"
     );
     logger.newLine();
-    logger.success("Your application has been submitted!");
-    logger.info("What happens next:", 1);
-    logger.data("1.", "We will review your application shortly", 1);
-    logger.data("2.", "Once approved, you can create and deploy games", 1);
-    logger.data("3.", "Use `playcademy games create` to create your first game", 1);
+    logger.admonition("tip", "Application Submitted!", [
+      "Your developer application has been submitted.",
+      "",
+      "What happens next:",
+      "  \u2022 We will review your application shortly",
+      "  \u2022 Once approved, you can create and deploy games"
+    ]);
     logger.newLine();
   } catch (error) {
-    logger.newLine();
     logger.error(
       `Failed to apply for developer status: ${error instanceof Error ? error.message : "Unknown error"}`
     );
@@ -11959,31 +12074,37 @@ var applyCommand = new Command11("apply").description("Apply for developer statu
 
 // src/commands/dev/get-status.ts
 import { Command as Command12 } from "commander";
-var getStatusCommand = new Command12("status").description("Check your developer status").action(async () => {
+var getStatusCommand = new Command12("status").description("Check your developer status").option(
+  "--env <environment>",
+  "Environment to check developer status from (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
-    logger.newLine();
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
+    logger.newLine();
     const status = await runStep(
-      "Fetching developer status",
+      `Fetching developer status from ${environment}`,
       () => client.dev.status.get(),
-      "Developer status retrieved"
+      `Developer status retrieved from ${environment}`
     );
-    logger.newLine();
-    logger.highlight("Developer Status");
-    logger.data("Status", status, 1);
     switch (status) {
       case "none":
         logger.newLine();
-        logger.info("You have not applied for developer status yet.");
-        logger.info("Run `playcademy dev apply` to apply.");
+        logger.admonition("warning", "Become a Developer", [
+          "Want to create and deploy games?",
+          "Run `playcademy dev apply` to apply for developer status"
+        ]);
         break;
       case "pending":
         logger.newLine();
-        logger.info("Your application is pending review.");
+        logger.admonition("warning", "Developer Status", [
+          "Your application is pending review."
+        ]);
         break;
       case "approved":
         logger.newLine();
-        logger.success("You are an approved developer!");
+        logger.admonition("note", "Approved!", ["You are an approved developer!"]);
         break;
       default:
         logger.newLine();
@@ -12069,26 +12190,39 @@ import { Command as Command17 } from "commander";
 import { Command as Command14 } from "commander";
 async function listProfilesAction() {
   try {
-    const profiles = await listProfiles();
+    const profilesMap = await listProfiles();
     logger.newLine();
-    if (profiles.length === 0) {
+    let hasAnyProfiles = false;
+    for (const [, profiles] of profilesMap.entries()) {
+      if (profiles.length > 0) {
+        hasAnyProfiles = true;
+        break;
+      }
+    }
+    if (!hasAnyProfiles) {
       logger.warn("No authentication profiles found");
       logger.newLine();
       logger.admonition("tip", "Getting Started", [
         "Run `playcademy login` to create your first profile"
       ]);
+      logger.newLine();
       return;
     }
-    const tableData = [];
-    for (const profileName of profiles.values()) {
-      const profile = await getProfile(profileName);
-      tableData.push({
-        Profile: profileName,
-        Email: profile?.email ?? ""
-      });
-    }
-    if (tableData.length > 0) {
-      logger.table(tableData);
+    for (const [environment, profiles] of profilesMap.entries()) {
+      if (profiles.length === 0) continue;
+      logger.highlight(`${environment.charAt(0).toUpperCase() + environment.slice(1)}:`);
+      const tableData = [];
+      for (const profileName of profiles) {
+        const profile = await getProfile(environment, profileName);
+        tableData.push({
+          Profile: profileName,
+          Email: profile?.email ?? ""
+        });
+      }
+      if (tableData.length > 0) {
+        logger.table(tableData);
+        logger.newLine();
+      }
     }
   } catch (error) {
     logger.error(
@@ -12096,28 +12230,29 @@ async function listProfilesAction() {
     );
     process.exit(1);
   }
-  logger.newLine();
 }
 var listCommand2 = new Command14("list").alias("ls").description("List all stored authentication profiles").action(listProfilesAction);
 
 // src/commands/profiles/remove.ts
+import { bold as bold5 } from "colorette";
 import { Command as Command15 } from "commander";
-var removeCommand = new Command15("remove <name>").alias("rm").description("Remove an authentication profile").action(async (name) => {
+var removeCommand = new Command15("remove").alias("rm").description('Remove an authentication profile (defaults to "default")').argument("[name]", "Profile name to remove", "default").option("--env <environment>", "Environment to remove profile from (staging or production)").action(async (name, options) => {
+  const { env } = options;
+  const environment = ensureEnvironment(env, logger);
   try {
     logger.newLine();
-    const profiles = await listProfiles();
-    if (!profiles.includes(name)) {
-      logger.error(`Profile "${name}" not found`);
+    const profilesMap = await listProfiles();
+    const envProfiles = profilesMap.get(environment) || [];
+    if (!envProfiles.includes(name)) {
+      logger.error(`Profile "${name}" not found in ${environment}`);
       logger.newLine();
       process.exit(1);
     }
-    await removeProfile(name);
-    logger.success(`Profile "${name}" removed successfully`);
-    if (name !== "default") {
-      logger.info(`To re-authenticate: playcademy login --profile ${name}`);
-    } else {
-      logger.info("To re-authenticate: playcademy login");
-    }
+    await removeProfile(environment, name);
+    logger.admonition("note", "Removed!", [
+      `Profile ${bold5(name)} removed from ${environment}`,
+      environment === "production" ? `To re-authenticate run \`playcademy login --env ${environment}\`` : "To re-authenticate run `playcademy login`"
+    ]);
     logger.newLine();
   } catch (error) {
     logger.newLine();
@@ -12132,10 +12267,16 @@ var removeCommand = new Command15("remove <name>").alias("rm").description("Remo
 // src/commands/profiles/reset.ts
 import { confirm as confirm6 } from "@inquirer/prompts";
 import { Command as Command16 } from "commander";
-var resetCommand = new Command16("reset").description("Remove all authentication profiles (requires confirmation)").alias("clear").action(async () => {
+var resetCommand = new Command16("reset").description(
+  "Remove all authentication profiles across all environments (requires confirmation)"
+).alias("clear").action(async () => {
   try {
-    const profiles = await listProfiles();
-    if (profiles.length === 0) {
+    const profilesMap = await listProfiles();
+    let totalProfiles = 0;
+    for (const profiles of profilesMap.values()) {
+      totalProfiles += profiles.length;
+    }
+    if (totalProfiles === 0) {
       logger.newLine();
       logger.warn("No authentication profiles found");
       logger.newLine();
@@ -12143,14 +12284,21 @@ var resetCommand = new Command16("reset").description("Remove all authentication
     }
     logger.newLine();
     logger.warn(
-      `This will remove ${profiles.length} authentication profile${profiles.length > 1 ? "s" : ""}:`
+      `This will remove ${totalProfiles} authentication profile${totalProfiles > 1 ? "s" : ""} across all environments:`
     );
     logger.newLine();
-    for (const profileName of profiles) {
-      const profile = await getProfile(profileName);
-      logger.data(profileName, profile?.email || "", 1);
+    for (const [environment, profiles] of profilesMap.entries()) {
+      if (profiles.length === 0) continue;
+      logger.highlight(
+        `${environment.charAt(0).toUpperCase() + environment.slice(1)}:`,
+        1
+      );
+      for (const profileName of profiles) {
+        const profile = await getProfile(environment, profileName);
+        logger.data(profileName, profile?.email || "", 2);
+      }
+      logger.newLine();
     }
-    logger.newLine();
     const confirmed = await confirm6({
       message: "Are you sure you want to remove all profiles?",
       default: false
@@ -12160,23 +12308,27 @@ var resetCommand = new Command16("reset").description("Remove all authentication
       return;
     }
     let removedCount = 0;
-    for (const profileName of profiles) {
-      try {
-        await removeProfile(profileName);
-        removedCount++;
-      } catch (error) {
-        logger.newLine();
-        logger.error(`Failed to remove profile "${profileName}"`);
-        logger.error(error instanceof Error ? error.message : "Unknown error");
-        logger.newLine();
+    for (const [environment, profiles] of profilesMap.entries()) {
+      for (const profileName of profiles) {
+        try {
+          await removeProfile(environment, profileName);
+          removedCount++;
+        } catch (error) {
+          logger.newLine();
+          logger.error(
+            `Failed to remove profile "${profileName}" from ${environment}`
+          );
+          logger.error(error instanceof Error ? error.message : "Unknown error");
+          logger.newLine();
+        }
       }
     }
-    if (removedCount === profiles.length) {
+    if (removedCount === totalProfiles) {
       logger.success(
         `${removedCount > 1 ? "All " : ""}${removedCount} profile${removedCount > 1 ? "s" : ""} removed successfully`
       );
     } else {
-      logger.warn(`Removed ${removedCount} of ${profiles.length} profiles`);
+      logger.warn(`Removed ${removedCount} of ${totalProfiles} profiles`);
     }
     logger.newLine();
   } catch (error) {
@@ -12201,13 +12353,18 @@ import { Command as Command22 } from "commander";
 // src/commands/timeback/cleanup.ts
 import { confirm as confirm7 } from "@inquirer/prompts";
 import { Command as Command18 } from "commander";
-var cleanupCommand = new Command18("cleanup").description("Remove TimeBack integration for your game").action(async () => {
+var cleanupCommand = new Command18("cleanup").description("Remove TimeBack integration for your game").option(
+  "--env <environment>",
+  "Environment to remove TimeBack integration from (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
-    logger.newLine();
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
+    logger.newLine();
     const { game } = await getGameFromConfig(client);
     const integration = await runStep(
-      "Checking for TimeBack integration",
+      `Checking for TimeBack integration in ${environment}`,
       () => client.timeback.management.get(game.id),
       "Integration status checked"
     );
@@ -12230,9 +12387,9 @@ var cleanupCommand = new Command18("cleanup").description("Remove TimeBack integ
     }
     logger.newLine();
     await runStep(
-      "Removing TimeBack integration",
+      `Removing TimeBack integration from ${environment}`,
       () => client.timeback.management.cleanup(game.id),
-      "TimeBack integration removed"
+      `TimeBack integration removed from ${environment}`
     );
     logger.newLine();
     logger.admonition("note", "Note", [
@@ -12251,8 +12408,13 @@ var cleanupCommand = new Command18("cleanup").description("Remove TimeBack integ
 // src/commands/timeback/setup.ts
 import { Command as Command19 } from "commander";
 import dedent from "dedent";
-var setupCommand = new Command19("setup").description("Set up TimeBack integration for your game").option("--dry-run", "Validate configuration without creating resources").option("--verbose, -v", "Output detailed information").action(async (options) => {
+var setupCommand = new Command19("setup").description("Set up TimeBack integration for your game").option("--dry-run", "Validate configuration without creating resources").option("--verbose, -v", "Output detailed information").option(
+  "--env <environment>",
+  "Environment to set up TimeBack integration in (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
+    ensureEnvironment(env, logger);
     logger.newLine();
     const config = await runStep(
       "Loading configuration",
@@ -12354,8 +12516,13 @@ var setupCommand = new Command19("setup").description("Set up TimeBack integrati
 import { confirm as confirm8 } from "@inquirer/prompts";
 import { green as green3, red as red3 } from "colorette";
 import { Command as Command20 } from "commander";
-var updateCommand = new Command20("update").description("Update TimeBack integration configuration for your game").option("--verbose, -v", "Output detailed information").action(async (options) => {
+var updateCommand = new Command20("update").description("Update TimeBack integration configuration for your game").option("--verbose, -v", "Output detailed information").option(
+  "--env <environment>",
+  "Environment to update TimeBack integration in (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
+    ensureEnvironment(env, logger);
     logger.newLine();
     const config = await runStep(
       "Loading configuration",
@@ -12461,13 +12628,18 @@ var updateCommand = new Command20("update").description("Update TimeBack integra
 
 // src/commands/timeback/verify.ts
 import { Command as Command21 } from "commander";
-var verifyCommand = new Command21("verify").description("Verify TimeBack integration for your game").option("--verbose, -v", "Output detailed resource information").action(async (options) => {
+var verifyCommand = new Command21("verify").description("Verify TimeBack integration for your game").option("--verbose, -v", "Output detailed resource information").option(
+  "--env <environment>",
+  "Environment to verify TimeBack integration in (staging or production)"
+).action(async (options) => {
+  const { env } = options;
   try {
-    logger.newLine();
+    const environment = ensureEnvironment(env, logger);
     const client = await requireAuthenticatedClient();
+    logger.newLine();
     const { game } = await getGameFromConfig(client);
     const result = await runStep(
-      "Verifying TimeBack integration",
+      `Verifying TimeBack integration in ${environment}`,
       () => client.timeback.management.verify(game.id),
       "Verification complete"
     );
@@ -12508,11 +12680,12 @@ timebackCommand.addCommand(cleanupCommand);
 var __dirname = dirname4(fileURLToPath2(import.meta.url));
 var packageJson = await loadPackageJson({ cwd: __dirname, searchUp: true, required: true });
 program.name("playcademy").description("CLI for deploying and managing Playcademy games").version(packageJson?.version || "0.0.0").option("--profile <name>", "Use a specific authentication profile", "default").hook("preAction", (thisCommand) => {
-  const options = thisCommand.opts();
+  const options = thisCommand.optsWithGlobals();
   setCliContext({ profile: options.profile, workspace: process.cwd() });
 });
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
 program.addCommand(profilesCommand);
 program.addCommand(meCommand);
 program.addCommand(devCommand);
@@ -12550,6 +12723,7 @@ export {
   displayRegisteredRoutes,
   displayResourcesStatus,
   displaySuccessMessage,
+  ensureEnvironment,
   ensureGameExists,
   findConfigPath,
   generateEntryCode,
@@ -12557,6 +12731,7 @@ export {
   generateJsonConfig,
   getApiUrl,
   getAuthPath,
+  getAuthenticatedEnvironments,
   getBackendHash,
   getBackendSize,
   getBaseUrl,
@@ -12588,6 +12763,7 @@ export {
   loadGameStore,
   logger,
   needsBackend,
+  normalizeEnvironment,
   prepareDeploymentContext,
   processConfigVariables,
   promptForApiRoutes,

package/dist/types.d.ts

@@ -23,15 +23,28 @@ interface AuthProfile {
     /** ISO 8601 date string - when the token expires (if applicable) */
     expiresAt?: string;
 }
+/**
+ * Environment-specific auth profiles
+ * Each environment (staging, production) has its own set of profiles
+ */
+interface EnvironmentAuthProfiles {
+    /** Default authentication profile for this environment */
+    default: AuthProfile | null;
+    /** Named authentication profiles for this environment */
+    profiles: Record<string, AuthProfile>;
+}
 /**
  * The complete auth store structure
  * CLI-specific type for ~/.playcademy/auth.json
+ *
+ * Profiles are scoped per environment to ensure staging and production
+ * credentials are kept separate for security.
  */
 interface AuthStore {
-    /** Default authentication profile used when no profile is specified */
-    default: AuthProfile | null;
-    /** Named authentication profiles for different environments/contexts */
-    profiles: Record<string, AuthProfile>;
+    /** Staging environment profiles */
+    staging: EnvironmentAuthProfiles;
+    /** Production environment profiles */
+    production: EnvironmentAuthProfiles;
 }
 /**
  * Login credentials for email/password authentication
@@ -486,7 +499,7 @@ interface DeploymentContext {
     projectPath: string;
     existingGame?: Game;
     deployedGameInfo?: DeployedGameInfo;
-    isNewDeployment: boolean;
+    isGameDeployed: boolean;
     buildHash?: string;
     buildSize?: number;
     previousBuildHash?: string;
@@ -625,4 +638,4 @@ interface PreviewResponse {
     qrCode?: string;
 }
 
-export type { ApiConfig, ApiErrorResponse, ApiKeyListItem, ApiKeyWithSecret, ApiRequestOptions, AuthProfile, AuthStore, BackendDeploymentWithHash, CallbackServerResult, CreateApiKeyResponse, DeployConfig, DeployNewGameOptions, DeployedGameInfo, DeploymentChanges, DeploymentContext, DeploymentPlan, DeploymentResult, GameStore, IntegrationsConfig, LoginCredentials, LoginResponse, PlaycademyConfig, PreviewOptions, PreviewResponse, SignInResponse, SsoCallbackData, TimebackIntegrationConfig, TokenType, UpdateExistingGameOptions };
+export type { ApiConfig, ApiErrorResponse, ApiKeyListItem, ApiKeyWithSecret, ApiRequestOptions, AuthProfile, AuthStore, BackendDeploymentWithHash, CallbackServerResult, CreateApiKeyResponse, DeployConfig, DeployNewGameOptions, DeployedGameInfo, DeploymentChanges, DeploymentContext, DeploymentPlan, DeploymentResult, EnvironmentAuthProfiles, GameStore, IntegrationsConfig, LoginCredentials, LoginResponse, PlaycademyConfig, PreviewOptions, PreviewResponse, SignInResponse, SsoCallbackData, TimebackIntegrationConfig, TokenType, UpdateExistingGameOptions };

package/dist/utils.js

@@ -4548,15 +4548,7 @@ function createDevNamespace(client) {
               throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
             }
           }
-          const baseUrl = (() => {
-            const anyClient = client;
-            try {
-              return typeof anyClient.getBaseUrl === "function" ? anyClient.getBaseUrl() : "/api";
-            } catch {
-              return "/api";
-            }
-          })();
-          const finalizeUrl = baseUrl.replace(/\/$/, "") + "/games/uploads/finalize/";
+          const finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
           const authToken = client.getToken();
           const tokenType = client.getTokenType();
           const headers = {
@@ -6034,13 +6026,13 @@ var init_achievements = () => {
 function createTimebackNamespace(client) {
   return {
     recordProgress: (progressData) => {
-      return client["request"]("/api/integrations/timeback/progress", "POST", { progressData }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/progress", "POST", { progressData });
     },
     recordSessionEnd: (sessionData) => {
-      return client["request"]("/api/integrations/timeback/session-end", "POST", { sessionData }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/session-end", "POST", { sessionData });
     },
     awardXP: (xpAmount, metadata) => {
-      return client["request"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata }, void 0, true);
+      return client["requestGameBackend"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata });
     },
     management: {
       setup: (request2) => {
@@ -6349,7 +6341,7 @@ var init_client = __esm2(() => {
     authContext;
     initPayload;
     constructor(config) {
-      this.baseUrl = config?.baseUrl || "";
+      this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
       this.gameUrl = config?.gameUrl;
       this.gameId = config?.gameId;
       this.config = config || {};
@@ -6365,8 +6357,9 @@ var init_client = __esm2(() => {
       return `${effectiveBaseUrl}/api`;
     }
     getGameBackendUrl() {
-      if (!this.gameUrl)
-        return this.getBaseUrl();
+      if (!this.gameUrl) {
+        throw new PlaycademyError("Game backend URL not configured. gameUrl must be set to use game backend features.");
+      }
       const isRelative = this.gameUrl.startsWith("/");
       const isBrowser2 = typeof window !== "undefined";
       const effectiveGameUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.gameUrl}` : this.gameUrl;
@@ -6403,17 +6396,29 @@ var init_client = __esm2(() => {
         listener(payload);
       });
     }
-    async request(path, method, body, headers, useGameBackend = false) {
+    async request(path, method, body, headers) {
+      const effectiveHeaders = {
+        ...headers,
+        ...this.authStrategy.getHeaders()
+      };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.baseUrl,
+        extraHeaders: effectiveHeaders
+      });
+    }
+    async requestGameBackend(path, method, body, headers) {
       const effectiveHeaders = {
         ...headers,
         ...this.authStrategy.getHeaders()
       };
-      const targetBaseUrl = useGameBackend ? this.getGameBackendUrl() : this.baseUrl;
       return request({
         path,
         method,
         body,
-        baseUrl: targetBaseUrl,
+        baseUrl: this.getGameBackendUrl(),
         extraHeaders: effectiveHeaders
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "playcademy",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "type": "module",
     "module": "./dist/index.js",
     "exports": {