playcademy 0.14.11 → 0.14.12-alpha.1

package/dist/constants.d.ts

@@ -155,6 +155,59 @@ declare const SCHEMA_INDEX_FILE = "index.ts";
  */
 declare const DEFAULT_SEED_FILE_NAME = "seed.ts";
 
+/**
+ * Godot engine integration constants
+ *
+ * Constants for detecting Godot projects and running headless exports
+ */
+/**
+ * Godot project file (presence indicates Godot project)
+ */
+declare const GODOT_PROJECT_FILE = "project.godot";
+/**
+ * Godot export presets configuration file
+ */
+declare const GODOT_EXPORT_PRESETS_FILE = "export_presets.cfg";
+/**
+ * Web platform identifier in export_presets.cfg
+ */
+declare const GODOT_WEB_PLATFORM = "platform=\"Web\"";
+/**
+ * Build output directories
+ */
+declare const GODOT_BUILD_DIRECTORIES: {
+    /** Root build directory (cleared before each export) */
+    readonly ROOT: "build";
+    /** Web export subdirectory */
+    readonly WEB: "build/web";
+};
+/**
+ * Build output file paths
+ */
+declare const GODOT_BUILD_OUTPUTS: {
+    /** Exported web build entry point */
+    readonly INDEX_HTML: "build/web/index.html";
+    /** Packaged zip file (created by Godot export) */
+    readonly ZIP: "build/web_playcademy.zip";
+};
+/**
+ * Platform-specific Godot executable discovery patterns
+ */
+declare const GODOT_EXECUTABLE_PATTERNS: {
+    /** macOS app bundle suffix */
+    readonly MACOS_APP_SUFFIX: ".app/";
+    /** macOS executable path within .app bundle */
+    readonly MACOS_APP_EXECUTABLE: "Contents/MacOS/Godot";
+    /** Flatpak application ID */
+    readonly FLATPAK_ID: "org.godotengine.Godot";
+    /** Flatpak run command */
+    readonly FLATPAK_COMMAND: "flatpak run org.godotengine.Godot";
+    /** Snap package name */
+    readonly SNAP_NAME: "godot";
+    /** Snap run command */
+    readonly SNAP_COMMAND: "snap run godot";
+};
+
 /**
  * HTTP server constants for CLI OAuth callback handling
  */
@@ -223,4 +276,4 @@ declare const DEFAULT_PORTS: {
  */
 declare const CONFIG_FILE_NAMES: string[];
 
-export { AUTH_API_SUBDIRECTORY, AUTH_CONFIG_FILE, AUTH_PROVIDER_NAMES, BETTER_AUTH_VERSION, BUCKET_ALWAYS_SKIP, CALLBACK_PATH, CALLBACK_PORT, CLI_DEFAULT_OUTPUTS, CLI_DIRECTORIES, CLI_FILES, CLI_USER_DIRECTORIES, CLOUDFLARE_BINDINGS, CLOUDFLARE_COMPATIBILITY_DATE, CONFIG_FILE_NAMES, DEFAULT_API_ROUTES_DIRECTORY, DEFAULT_DATABASE_DIRECTORY, DEFAULT_PORTS, DEFAULT_SEED_FILE_NAME, ENV_EXAMPLE_FILE, ENV_FILES, MINIFLARE_D1_DIRECTORY, OAUTH_CALLBACK_URL_PATTERN, PLACEHOLDER_GAME_URL, PLAYCADEMY_AUTH_VERSION, SAMPLE_API_SUBDIRECTORY, SAMPLE_BUCKET_FILENAME, SAMPLE_CUSTOM_FILENAME, SAMPLE_DATABASE_FILENAME, SAMPLE_KV_FILENAME, SCHEMA_INDEX_FILE, SCHEMA_SUBDIRECTORY, SERVER_LIB_DIRECTORY, SERVER_ROOT_DIRECTORY, SSO_AUTH_TIMEOUT_MS, TSCONFIG_FILES, WORKSPACE_NAME };
+export { AUTH_API_SUBDIRECTORY, AUTH_CONFIG_FILE, AUTH_PROVIDER_NAMES, BETTER_AUTH_VERSION, BUCKET_ALWAYS_SKIP, CALLBACK_PATH, CALLBACK_PORT, CLI_DEFAULT_OUTPUTS, CLI_DIRECTORIES, CLI_FILES, CLI_USER_DIRECTORIES, CLOUDFLARE_BINDINGS, CLOUDFLARE_COMPATIBILITY_DATE, CONFIG_FILE_NAMES, DEFAULT_API_ROUTES_DIRECTORY, DEFAULT_DATABASE_DIRECTORY, DEFAULT_PORTS, DEFAULT_SEED_FILE_NAME, ENV_EXAMPLE_FILE, ENV_FILES, GODOT_BUILD_DIRECTORIES, GODOT_BUILD_OUTPUTS, GODOT_EXECUTABLE_PATTERNS, GODOT_EXPORT_PRESETS_FILE, GODOT_PROJECT_FILE, GODOT_WEB_PLATFORM, MINIFLARE_D1_DIRECTORY, OAUTH_CALLBACK_URL_PATTERN, PLACEHOLDER_GAME_URL, PLAYCADEMY_AUTH_VERSION, SAMPLE_API_SUBDIRECTORY, SAMPLE_BUCKET_FILENAME, SAMPLE_CUSTOM_FILENAME, SAMPLE_DATABASE_FILENAME, SAMPLE_KV_FILENAME, SCHEMA_INDEX_FILE, SCHEMA_SUBDIRECTORY, SERVER_LIB_DIRECTORY, SERVER_ROOT_DIRECTORY, SSO_AUTH_TIMEOUT_MS, TSCONFIG_FILES, WORKSPACE_NAME };

package/dist/constants.js

@@ -171,6 +171,37 @@ var SCHEMA_SUBDIRECTORY = "schema";
 var SCHEMA_INDEX_FILE = "index.ts";
 var DEFAULT_SEED_FILE_NAME = "seed.ts";
 
+// src/constants/godot.ts
+var GODOT_PROJECT_FILE = "project.godot";
+var GODOT_EXPORT_PRESETS_FILE = "export_presets.cfg";
+var GODOT_WEB_PLATFORM = 'platform="Web"';
+var GODOT_BUILD_DIRECTORIES = {
+  /** Root build directory (cleared before each export) */
+  ROOT: "build",
+  /** Web export subdirectory */
+  WEB: "build/web"
+};
+var GODOT_BUILD_OUTPUTS = {
+  /** Exported web build entry point */
+  INDEX_HTML: "build/web/index.html",
+  /** Packaged zip file (created by Godot export) */
+  ZIP: "build/web_playcademy.zip"
+};
+var GODOT_EXECUTABLE_PATTERNS = {
+  /** macOS app bundle suffix */
+  MACOS_APP_SUFFIX: ".app/",
+  /** macOS executable path within .app bundle */
+  MACOS_APP_EXECUTABLE: "Contents/MacOS/Godot",
+  /** Flatpak application ID */
+  FLATPAK_ID: "org.godotengine.Godot",
+  /** Flatpak run command */
+  FLATPAK_COMMAND: "flatpak run org.godotengine.Godot",
+  /** Snap package name */
+  SNAP_NAME: "godot",
+  /** Snap run command */
+  SNAP_COMMAND: "snap run godot"
+};
+
 // src/constants/http-server.ts
 var CALLBACK_PORT = 6175;
 var CALLBACK_PATH = "/callback";
@@ -291,6 +322,12 @@ export {
   ENV_EXAMPLE_FILE,
   ENV_FILES,
   GAME_WORKER_DOMAINS,
+  GODOT_BUILD_DIRECTORIES,
+  GODOT_BUILD_OUTPUTS,
+  GODOT_EXECUTABLE_PATTERNS,
+  GODOT_EXPORT_PRESETS_FILE,
+  GODOT_PROJECT_FILE,
+  GODOT_WEB_PLATFORM,
   MINIFLARE_D1_DIRECTORY,
   OAUTH_CALLBACK_URL_PATTERN,
   PLACEHOLDER_GAME_URL,

package/dist/db.d.ts

@@ -75,6 +75,17 @@ declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
     debug?: boolean;
 }): Promise<void>;
 
+/**
+ * Environment context passed to seed functions
+ */
+interface SeedContext {
+    env: {
+        DB: unknown;
+        BUCKET?: unknown;
+        secrets?: Record<string, string>;
+    };
+}
+
 /**
  * Database Seed Utilities
  *
@@ -87,19 +98,17 @@ declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
  * Bundles all deps for portability.
  */
 declare function importSeedModule(seedPath: string): Promise<{
-    seed?: (c: {
-        env: {
-            DB: unknown;
-        };
-    }) => Promise<void>;
+    seed?: (c: SeedContext) => Promise<void>;
 }>;
+declare function getBucket(mf: Miniflare): Promise<unknown | null>;
 /**
- * Execute a seed file against a Miniflare D1 instance
+ * Execute a seed file against a Miniflare instance
  *
  * @param seedFilePath - Path to seed file
- * @param mf - Miniflare instance with D1 database
+ * @param mf - Miniflare instance with D1 database (and optionally bucket/secrets)
+ * @param envSecrets - Environment secrets from .env file
  */
-declare function executeSeedFile(seedFilePath: string, mf: Miniflare): Promise<void>;
+declare function executeSeedFile(seedFilePath: string, mf: Miniflare, envSecrets?: Record<string, string>): Promise<void>;
 
-export { bundleSeedWorker, executeSeedFile, getDevDbPath as getPath, importSeedModule, resetDatabase };
+export { bundleSeedWorker, executeSeedFile, getBucket, getDevDbPath as getPath, importSeedModule, resetDatabase };
 export type { SeedWorkerBundle };

package/dist/db.js

@@ -2938,7 +2938,14 @@ async function resetDatabase(workspace, mf, options = { debug: false }) {
 async function importSeedModule(seedPath) {
   return await importTypescriptFile(seedPath);
 }
-async function executeSeedFile(seedFilePath, mf) {
+async function getBucket(mf) {
+  try {
+    return await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+  } catch {
+    return null;
+  }
+}
+async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   const seedModule = await importSeedModule(seedFilePath);
   if (typeof seedModule.seed !== "function") {
@@ -2951,9 +2958,16 @@ async function executeSeedFile(seedFilePath, mf) {
     logger.newLine();
     process.exit(1);
   }
+  const bucket = await getBucket(mf);
+  const hasSecrets = Object.keys(envSecrets).length > 0;
   await runStep(
     "Seeding database...",
-    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    async () => {
+      const env = { DB: d1 };
+      if (bucket) env.BUCKET = bucket;
+      if (hasSecrets) env.secrets = envSecrets;
+      return seedModule.seed?.({ env });
+    },
     "Database seeded successfully!"
   );
   logger.newLine();
@@ -2961,6 +2975,7 @@ async function executeSeedFile(seedFilePath, mf) {
 export {
   bundleSeedWorker,
   executeSeedFile,
+  getBucket,
   getDevDbPath as getPath,
   importSeedModule,
   resetDatabase

package/dist/index.js

@@ -947,6 +947,43 @@ var init_database = __esm({
   }
 });
 
+// src/constants/godot.ts
+var GODOT_PROJECT_FILE, GODOT_EXPORT_PRESETS_FILE, GODOT_WEB_PLATFORM, GODOT_BUILD_DIRECTORIES, GODOT_BUILD_OUTPUTS, GODOT_EXECUTABLE_PATTERNS;
+var init_godot = __esm({
+  "src/constants/godot.ts"() {
+    "use strict";
+    GODOT_PROJECT_FILE = "project.godot";
+    GODOT_EXPORT_PRESETS_FILE = "export_presets.cfg";
+    GODOT_WEB_PLATFORM = 'platform="Web"';
+    GODOT_BUILD_DIRECTORIES = {
+      /** Root build directory (cleared before each export) */
+      ROOT: "build",
+      /** Web export subdirectory */
+      WEB: "build/web"
+    };
+    GODOT_BUILD_OUTPUTS = {
+      /** Exported web build entry point */
+      INDEX_HTML: "build/web/index.html",
+      /** Packaged zip file (created by Godot export) */
+      ZIP: "build/web_playcademy.zip"
+    };
+    GODOT_EXECUTABLE_PATTERNS = {
+      /** macOS app bundle suffix */
+      MACOS_APP_SUFFIX: ".app/",
+      /** macOS executable path within .app bundle */
+      MACOS_APP_EXECUTABLE: "Contents/MacOS/Godot",
+      /** Flatpak application ID */
+      FLATPAK_ID: "org.godotengine.Godot",
+      /** Flatpak run command */
+      FLATPAK_COMMAND: "flatpak run org.godotengine.Godot",
+      /** Snap package name */
+      SNAP_NAME: "godot",
+      /** Snap run command */
+      SNAP_COMMAND: "snap run godot"
+    };
+  }
+});
+
 // src/constants/http-server.ts
 var CALLBACK_PORT, CALLBACK_PATH, SSO_AUTH_TIMEOUT_MS;
 var init_http_server = __esm({
@@ -1156,6 +1193,7 @@ var init_constants = __esm({
     init_cloudflare();
     init_config();
     init_database();
+    init_godot();
     init_http_server();
     init_paths();
     init_ports();
@@ -5732,7 +5770,14 @@ init_core();
 async function importSeedModule(seedPath) {
   return await importTypescriptFile(seedPath);
 }
-async function executeSeedFile(seedFilePath, mf) {
+async function getBucket(mf) {
+  try {
+    return await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+  } catch {
+    return null;
+  }
+}
+async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   const seedModule = await importSeedModule(seedFilePath);
   if (typeof seedModule.seed !== "function") {
@@ -5745,9 +5790,16 @@ async function executeSeedFile(seedFilePath, mf) {
     logger.newLine();
     process.exit(1);
   }
+  const bucket = await getBucket(mf);
+  const hasSecrets = Object.keys(envSecrets).length > 0;
   await runStep(
     "Seeding database...",
-    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    async () => {
+      const env = { DB: d1 };
+      if (bucket) env.BUCKET = bucket;
+      if (hasSecrets) env.secrets = envSecrets;
+      return seedModule.seed?.({ env });
+    },
     "Database seeded successfully!"
   );
   logger.newLine();
@@ -6779,23 +6831,24 @@ function displayDeploymentDiff(options) {
 
 // src/lib/deploy/godot.ts
 init_src();
+init_constants2();
 init_core();
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync3 } from "fs";
 import { join as join13 } from "path";
 import { confirm, select } from "@inquirer/prompts";
 function isGodotProject() {
-  return existsSync10(join13(getWorkspace(), "project.godot"));
+  return existsSync10(join13(getWorkspace(), GODOT_PROJECT_FILE));
 }
 function hasWebExportPreset() {
-  const presetsPath = join13(getWorkspace(), "export_presets.cfg");
+  const presetsPath = join13(getWorkspace(), GODOT_EXPORT_PRESETS_FILE);
   if (!existsSync10(presetsPath)) {
     return { configured: false };
   }
   try {
     const content = readFileSync5(presetsPath, "utf-8");
     const lines = content.split("\n");
-    const webPlatformIndex = lines.findIndex((line) => line.trim() === 'platform="Web"');
+    const webPlatformIndex = lines.findIndex((line) => line.trim() === GODOT_WEB_PLATFORM);
     if (webPlatformIndex === -1) {
       return { configured: false };
     }
@@ -6824,8 +6877,8 @@ async function findGodotExecutable() {
     const result = execSync4(whichCmd, { stdio: "pipe", encoding: "utf-8" });
     const paths = result.trim().split("\n").filter(Boolean);
     for (const path4 of paths) {
-      if (platform === "darwin" && path4.includes(".app/")) {
-        const appPath = path4.split(".app/")[0] + ".app";
+      if (platform === "darwin" && path4.includes(GODOT_EXECUTABLE_PATTERNS.MACOS_APP_SUFFIX)) {
+        const appPath = path4.split(GODOT_EXECUTABLE_PATTERNS.MACOS_APP_SUFFIX)[0] + GODOT_EXECUTABLE_PATTERNS.MACOS_APP_SUFFIX.slice(0, -1);
         const appName = appPath.split("/").pop() || "Godot";
         foundExecutables.push({ path: path4, label: appName });
         seenAppBundles.add(appPath);
@@ -6844,7 +6897,7 @@ async function findGodotExecutable() {
       const apps = result.split("\n").filter(Boolean);
       for (const appPath of apps) {
         if (seenAppBundles.has(appPath)) continue;
-        const executable = join13(appPath, "Contents/MacOS/Godot");
+        const executable = join13(appPath, GODOT_EXECUTABLE_PATTERNS.MACOS_APP_EXECUTABLE);
         const appName = appPath.split("/").pop() || "Godot";
         foundExecutables.push({ path: executable, label: appName });
       }
@@ -6853,16 +6906,23 @@ async function findGodotExecutable() {
   }
   if (platform === "linux") {
     try {
-      execSync4("flatpak list 2>/dev/null | grep org.godotengine.Godot", { stdio: "pipe" });
+      execSync4(`flatpak list 2>/dev/null | grep ${GODOT_EXECUTABLE_PATTERNS.FLATPAK_ID}`, {
+        stdio: "pipe"
+      });
       foundExecutables.push({
-        path: "flatpak run org.godotengine.Godot",
+        path: GODOT_EXECUTABLE_PATTERNS.FLATPAK_COMMAND,
         label: "Godot (flatpak)"
       });
     } catch {
     }
     try {
-      execSync4("snap list 2>/dev/null | grep godot", { stdio: "pipe" });
-      foundExecutables.push({ path: "snap run godot", label: "Godot (snap)" });
+      execSync4(`snap list 2>/dev/null | grep ${GODOT_EXECUTABLE_PATTERNS.SNAP_NAME}`, {
+        stdio: "pipe"
+      });
+      foundExecutables.push({
+        path: GODOT_EXECUTABLE_PATTERNS.SNAP_COMMAND,
+        label: "Godot (snap)"
+      });
     } catch {
     }
   }
@@ -6899,7 +6959,11 @@ async function findGodotExecutable() {
 async function runGodotExport(godotPath, presetName, outputPath) {
   const root = getWorkspace();
   try {
-    mkdirSync2(join13(root, "build", "web"), { recursive: true });
+    const buildDir = join13(root, GODOT_BUILD_DIRECTORIES.ROOT);
+    if (existsSync10(buildDir)) {
+      rmSync3(buildDir, { recursive: true, force: true });
+    }
+    mkdirSync2(join13(root, GODOT_BUILD_DIRECTORIES.WEB), { recursive: true });
     await runStep(
       `Exporting project using "${presetName}" preset`,
       async () => {
@@ -6945,19 +7009,22 @@ async function handleGodotBuildPrompt() {
     logger.newLine();
     return null;
   }
-  const success = await runGodotExport(godotPath, webExport.presetName, "build/web/index.html");
+  const success = await runGodotExport(
+    godotPath,
+    webExport.presetName,
+    GODOT_BUILD_OUTPUTS.INDEX_HTML
+  );
   if (!success) {
     logger.error("Export failed. Please export manually or provide zip file.");
     logger.newLine();
     return null;
   }
-  const zipPath = "build/web_playcademy.zip";
-  if (existsSync10(join13(getWorkspace(), zipPath))) {
-    return zipPath;
+  if (existsSync10(join13(getWorkspace(), GODOT_BUILD_OUTPUTS.ZIP))) {
+    return GODOT_BUILD_OUTPUTS.ZIP;
   }
   logger.warn("Expected zip file not found, using build directory");
   logger.newLine();
-  return "build/web";
+  return GODOT_BUILD_DIRECTORIES.WEB;
 }
 
 // src/lib/deploy/interaction.ts
@@ -7070,8 +7137,11 @@ function scaffoldProtectedExample(workspace) {
   writeFileSync3(join14(sampleDir, "protected.ts"), protectedRouteTemplate);
 }
 function updateEnvForAuth(workspace, strategies) {
-  if (strategies.length === 0) return;
   const envLines = [];
+  envLines.push("# Better Auth (required)");
+  envLines.push("# Generate with: openssl rand -base64 32");
+  envLines.push("BETTER_AUTH_SECRET=your_secret_here");
+  envLines.push("");
   if (strategies.includes("github")) {
     envLines.push("# GitHub OAuth (for standalone auth)");
     envLines.push("GITHUB_CLIENT_ID=your_github_client_id");
@@ -7084,9 +7154,7 @@ function updateEnvForAuth(workspace, strategies) {
     envLines.push("GOOGLE_CLIENT_SECRET=your_google_client_secret");
     envLines.push("");
   }
-  if (envLines.length > 0) {
-    updateEnvExample(workspace, envLines);
-  }
+  updateEnvExample(workspace, envLines);
 }
 async function scaffoldAuthSetup(options = {}) {
   const workspace = getWorkspace();
@@ -7142,7 +7210,7 @@ import { join as join15 } from "path";
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.10",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {
@@ -8383,6 +8451,7 @@ async function reportDryRun(plan, context2) {
     logger.data("Update Game", String(plan.shouldUpdateGame), 1);
     logger.data("Upload Build", String(plan.shouldUploadBuild), 1);
     logger.data("Deploy Backend", String(plan.shouldDeployBackend), 1);
+    logger.newLine();
     const diff = plan.changes.config ? calculateConfigDiff(context2.existingGame, context2.config) : {};
     const currentIntegrationKeys = getIntegrationKeys(context2.fullConfig?.integrations);
     const schemaStatementCount = await getSchemaStatementCount(
@@ -8445,7 +8514,6 @@ async function reportDryRun(plan, context2) {
   } else {
     logger.remark("No changes detected");
   }
-  logger.newLine();
   logger.remark("Dry run complete");
   logger.newLine();
 }
@@ -11852,10 +11920,37 @@ async function runDbSeedRemote(seedFile, options) {
 async function runDbSeedLocal(seedFile, options) {
   const workspace = getWorkspace();
   const dbDir = join31(workspace, CLI_DIRECTORIES.DATABASE);
+  const config = await loadConfig();
+  const hasBucket = hasBucketSetup(config);
+  const hasKV = hasKVSetup(config);
+  const bucketDir = hasBucket ? join31(workspace, CLI_DIRECTORIES.BUCKET) : void 0;
+  const kvDir = hasKV ? join31(workspace, CLI_DIRECTORIES.KV) : void 0;
+  if (bucketDir) {
+    const { mkdir: mkdir5 } = await import("fs/promises");
+    await mkdir5(bucketDir, { recursive: true });
+  }
+  if (kvDir) {
+    const { mkdir: mkdir5 } = await import("fs/promises");
+    await mkdir5(kvDir, { recursive: true });
+  }
+  const envSecrets = await readEnvFile(workspace);
+  const bindings = {};
+  for (const [key, value] of Object.entries(envSecrets)) {
+    bindings[`secrets_${key}`] = value;
+  }
   const mf = new Miniflare3({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    bindings,
     d1Databases: [CLOUDFLARE_BINDINGS.DB],
     d1Persist: dbDir,
+    ...hasBucket && {
+      r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+      r2Persist: bucketDir
+    },
+    ...hasKV && {
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+      kvPersist: kvDir
+    },
     compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
   });
   logger.newLine();
@@ -11863,7 +11958,7 @@ async function runDbSeedLocal(seedFile, options) {
     await resetDatabase(workspace, mf, { debug: options.debug });
   }
   try {
-    await executeSeedFile(seedFile, mf);
+    await executeSeedFile(seedFile, mf, envSecrets);
   } finally {
     await mf.dispose();
   }
@@ -14901,6 +14996,7 @@ export {
   getAuthenticatedEnvironments,
   getBaseUrl,
   getBestUnit,
+  getBucket,
   getBucketKey,
   getCallbackUrl,
   getCliContext,

package/dist/templates/api/sample-database.ts.template

@@ -7,7 +7,7 @@
 
 import { desc } from 'drizzle-orm'
 
-import { getDb, schema } from '../../../db'
+import { getDb, schema } from 'db'
 
 /**
  * GET /api/sample/database

package/dist/templates/auth/auth.ts.template

@@ -11,10 +11,20 @@ import { playcademy } from '@playcademy/better-auth/server'
 
 import { getDb } from '../../db'
 
-import type { Context } from 'hono'
+function getAuthSecret(c: Context): string {
+    const secret = c.env.secrets?.BETTER_AUTH_SECRET
+    if (!secret) {
+        throw new Error(
+            'BETTER_AUTH_SECRET is required. ' +
+            'Set it locally in .env or deploy with: playcademy secret set BETTER_AUTH_SECRET <value>'
+        )
+    }
+    return secret
+}
 
 export function getAuth(c: Context) {
     const db = getDb(c.env.DB)
+    const secret = getAuthSecret(c)
 
     // CUSTOMIZABLE: Configure trusted origins for CORS
     // These origins are allowed to make cross-origin requests to your game's auth endpoints.
@@ -31,6 +41,8 @@ export function getAuth(c: Context) {
             usePlural: false,
         }),
 
+        secret,
+
         trustedOrigins,
 {{EMAIL_AND_PASSWORD}}{{SOCIAL_PROVIDERS}}
         // REQUIRED: Platform integration

package/dist/utils.js

@@ -3829,7 +3829,7 @@ import { join as join8 } from "path";
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.10",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {

package/dist/version.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "playcademy",
-  version: "0.14.10",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "playcademy",
-    "version": "0.14.11",
+    "version": "0.14.12-alpha.1",
     "type": "module",
     "exports": {
         ".": {