playcademy 0.11.14 → 0.12.0

package/dist/db.js

@@ -0,0 +1,671 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// ../utils/src/package-json.ts
+var init_package_json = __esm({
+  "../utils/src/package-json.ts"() {
+    "use strict";
+  }
+});
+
+// ../utils/src/file-loader.ts
+var init_file_loader = __esm({
+  "../utils/src/file-loader.ts"() {
+    "use strict";
+    init_package_json();
+  }
+});
+
+// src/lib/db/path.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import Database from "better-sqlite3";
+
+// src/constants/paths.ts
+var CLI_DIRECTORIES = {
+  /** Root directory for CLI artifacts in workspace */
+  WORKSPACE: ".playcademy",
+  /** Database directory within workspace */
+  DATABASE: ".playcademy/db"
+};
+var CLI_FILES = {
+  /** Auth store file in user config directory */
+  AUTH_STORE: "auth.json",
+  /** Games deployment info store */
+  GAMES_STORE: "games.json",
+  /** Dev server PID file */
+  DEV_SERVER_PID: "dev-server.pid",
+  /** Initial database file (before miniflare) */
+  INITIAL_DATABASE: "initial.sqlite"
+};
+
+// ../constants/src/overworld.ts
+var ITEM_SLUGS = {
+  /** Primary platform currency */
+  PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
+  /** Experience points currency */
+  PLAYCADEMY_XP: "PLAYCADEMY_XP",
+  /** Core platform badges */
+  FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
+  EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
+  FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
+  /** Example items */
+  COMMON_SWORD: "COMMON_SWORD",
+  SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
+  SMALL_BACKPACK: "SMALL_BACKPACK",
+  /** Placeable items */
+  LAVA_LAMP: "LAVA_LAMP",
+  BOOMBOX: "BOOMBOX",
+  CABIN_BED: "CABIN_BED"
+};
+var CURRENCIES = {
+  /** Primary platform currency slug */
+  PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+  /** Experience points slug */
+  XP: ITEM_SLUGS.PLAYCADEMY_XP
+};
+var BADGES = {
+  FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+  EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+  FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
+};
+
+// src/lib/db/path.ts
+var DB_DIRECTORY = CLI_DIRECTORIES.DATABASE;
+var INITIAL_DB_NAME = CLI_FILES.INITIAL_DATABASE;
+var ensureDirectoryExists = (dir) => {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+};
+var createEmptyDatabase = (path) => {
+  const db = new Database(path);
+  db.close();
+};
+var findMiniflareDatabase = (dbDir) => {
+  const miniflareDir = join(dbDir, "miniflare-D1DatabaseObject");
+  if (!existsSync(miniflareDir)) return null;
+  const sqliteFiles = readdirSync(miniflareDir).filter((file) => file.endsWith(".sqlite"));
+  if (sqliteFiles.length === 0) return null;
+  return join(miniflareDir, sqliteFiles[0]);
+};
+var migrateInitialDbToTarget = (initialPath, targetPath) => {
+  if (!existsSync(initialPath)) return;
+  copyFileSync(initialPath, targetPath);
+  unlinkSync(initialPath);
+};
+function getDevDbPath() {
+  const initialDbPath = join(DB_DIRECTORY, INITIAL_DB_NAME);
+  ensureDirectoryExists(DB_DIRECTORY);
+  const miniflareDbPath = findMiniflareDatabase(DB_DIRECTORY);
+  if (miniflareDbPath) {
+    migrateInitialDbToTarget(initialDbPath, miniflareDbPath);
+    return miniflareDbPath;
+  }
+  if (!existsSync(initialDbPath)) {
+    createEmptyDatabase(initialDbPath);
+  }
+  return initialDbPath;
+}
+
+// src/lib/db/reset.ts
+import { execSync as execSync2 } from "child_process";
+import Database2 from "better-sqlite3";
+
+// ../utils/src/ansi.ts
+var colors = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var styles = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  up: (n) => `\x1B[${n}A`,
+  down: (n) => `\x1B[${n}B`,
+  forward: (n) => `\x1B[${n}C`,
+  back: (n) => `\x1B[${n}D`,
+  clearLine: "\x1B[K",
+  clearScreen: "\x1B[2J",
+  home: "\x1B[H"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${styles.reset}`;
+}
+function dim(text) {
+  return color(text, styles.dim);
+}
+function bold(text) {
+  return color(text, styles.bold);
+}
+var isInteractive = typeof process !== "undefined" && process.stdout?.isTTY && !process.env.CI && process.env.TERM !== "dumb";
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+// ../utils/src/spinner.ts
+import { stdout } from "process";
+var SPINNER_FRAMES = [
+  10251,
+  10265,
+  10297,
+  10296,
+  10300,
+  10292,
+  10278,
+  10279,
+  10247,
+  10255
+].map((code) => String.fromCodePoint(code));
+var CHECK_MARK = String.fromCodePoint(10004);
+var CROSS_MARK = String.fromCodePoint(10006);
+var SPINNER_INTERVAL = 80;
+var Spinner = class {
+  tasks = /* @__PURE__ */ new Map();
+  frameIndex = 0;
+  intervalId = null;
+  renderCount = 0;
+  previousLineCount = 0;
+  printedTasks = /* @__PURE__ */ new Set();
+  indent;
+  constructor(taskIds, texts, options) {
+    this.indent = options?.indent ?? 0;
+    taskIds.forEach((id, index) => {
+      this.tasks.set(id, {
+        text: texts[index] || "",
+        status: "pending"
+      });
+    });
+  }
+  start() {
+    if (isInteractive) {
+      stdout.write(cursor.hide);
+      this.render();
+      this.intervalId = setInterval(() => {
+        this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, SPINNER_INTERVAL);
+    }
+  }
+  updateTask(taskId, status, finalText) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      task.status = status;
+      if (finalText) task.finalText = finalText;
+      if (!isInteractive) {
+        this.renderNonInteractive(taskId, task);
+      }
+    }
+  }
+  renderNonInteractive(taskId, task) {
+    const key = `${taskId}-${task.status}`;
+    if (this.printedTasks.has(key)) return;
+    this.printedTasks.add(key);
+    const indentStr = "  ".repeat(this.indent);
+    let line = "";
+    switch (task.status) {
+      case "running":
+        line = `${indentStr}[RUNNING] ${stripAnsi(task.text)}`;
+        break;
+      case "success":
+        line = `${indentStr}[SUCCESS] ${stripAnsi(task.finalText || task.text)}`;
+        break;
+      case "error":
+        line = `${indentStr}[ERROR] Failed: ${stripAnsi(task.text)}`;
+        break;
+    }
+    console.log(line);
+  }
+  render() {
+    if (this.previousLineCount > 0) {
+      stdout.write(cursor.up(this.previousLineCount));
+    }
+    const spinner = SPINNER_FRAMES[this.frameIndex];
+    const indentStr = "  ".repeat(this.indent);
+    const visibleTasks = Array.from(this.tasks.values()).filter(
+      (task) => task.status !== "pending"
+    );
+    for (const task of visibleTasks) {
+      stdout.write(`\r${cursor.clearLine}`);
+      let line = "";
+      switch (task.status) {
+        case "running":
+          line = `${indentStr}${colors.blue}${spinner}${styles.reset} ${task.text}`;
+          break;
+        case "success":
+          line = `${indentStr}${colors.green}${CHECK_MARK}${styles.reset} ${task.finalText || task.text}`;
+          break;
+        case "error":
+          line = `${indentStr}${colors.red}${CROSS_MARK}${styles.reset} Failed: ${task.text}`;
+          break;
+      }
+      console.log(line);
+    }
+    this.previousLineCount = visibleTasks.length;
+    this.renderCount++;
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive) {
+      this.render();
+      stdout.write(cursor.show);
+    } else {
+      this.tasks.forEach((task, taskId) => {
+        if (task.status !== "pending") {
+          this.renderNonInteractive(taskId, task);
+        }
+      });
+    }
+  }
+};
+
+// ../utils/src/log.ts
+function formatDuration(ms) {
+  const duration = ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(2)}s`;
+  return bold(dim(`[${duration}]`));
+}
+async function runStep(text, action, successText, options) {
+  const effectiveAction = action ?? (async () => void 0);
+  const hasAction = action !== void 0;
+  const indent = options?.indent ?? 0;
+  const spinner = new Spinner(["task"], [text], { indent });
+  if (!options?.silent) {
+    spinner.start();
+    spinner.updateTask("task", "running");
+  }
+  const startTime = performance.now();
+  try {
+    const result = await effectiveAction();
+    if (options?.silent) {
+      return result;
+    }
+    const duration = performance.now() - startTime;
+    let finalSuccessText;
+    if (typeof successText === "function") {
+      finalSuccessText = successText(result);
+    } else {
+      finalSuccessText = successText ?? text;
+    }
+    finalSuccessText = bold(finalSuccessText);
+    if (hasAction) {
+      const durationText = formatDuration(duration);
+      finalSuccessText = `${finalSuccessText} ${durationText}`;
+    }
+    spinner.updateTask("task", "success", finalSuccessText);
+    spinner.stop();
+    return result;
+  } catch (error) {
+    if (!options?.silent) {
+      spinner.updateTask("task", "error");
+      spinner.stop();
+    }
+    console.error("");
+    if (error && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number") {
+      console.error(`  Exit Code: ${error.exitCode}`);
+      const stdout2 = error.stdout?.toString().trim();
+      const stderr = error.stderr?.toString().trim();
+      const indent2 = (str) => str.split("\n").map((line) => `    ${line}`).join("\n");
+      if (stdout2) console.error(`  Stdout:
+ ${indent2(stdout2)}`);
+      if (stderr) console.error(`  Stderr:
+ ${indent2(stderr)}`);
+    } else {
+      console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.error("");
+    throw error;
+  }
+}
+
+// ../utils/src/package-manager.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function isCommandAvailable(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync2(join2(cwd, "bun.lock")) || existsSync2(join2(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync2(join2(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync2(join2(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return detectByCommandAvailability();
+}
+function detectByCommandAvailability() {
+  if (isCommandAvailable("bun")) {
+    return "bun";
+  }
+  if (isCommandAvailable("pnpm")) {
+    return "pnpm";
+  }
+  if (isCommandAvailable("yarn")) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "bun":
+      return `bun run ${script}`;
+    case "pnpm":
+      return `pnpm run ${script}`;
+    case "yarn":
+      return `yarn run ${script}`;
+    case "npm":
+    default:
+      return `npm run ${script}`;
+  }
+}
+
+// src/lib/core/client.ts
+import { PlaycademyClient } from "@playcademy/sdk";
+
+// src/lib/core/context.ts
+var context = {};
+var cache = {
+  packageManager: null
+};
+function getWorkspace() {
+  return context.workspace || process.cwd();
+}
+function getPackageManager() {
+  if (cache.packageManager) return cache.packageManager;
+  cache.packageManager = detectPackageManager(getWorkspace());
+  return cache.packageManager;
+}
+
+// src/lib/core/logger.ts
+import {
+  blue,
+  bold as bold2,
+  cyan,
+  dim as dim2,
+  gray,
+  green,
+  greenBright,
+  red,
+  yellow,
+  yellowBright
+} from "colorette";
+import { colorize } from "json-colorizer";
+function customTransform(text) {
+  const highlightCode = (text2) => text2.replace(/`([^`]+)`/g, (_, code) => greenBright(code));
+  return highlightCode(text);
+}
+function formatTable(data, title) {
+  if (data.length === 0) return;
+  const keys = Object.keys(data[0]);
+  const rows = data.map((item) => keys.map((key) => String(item[key] ?? "")));
+  const widths = keys.map((key, i) => {
+    const headerWidth = key.length;
+    const dataWidth = Math.max(...rows.map((row) => row[i].length));
+    return Math.max(headerWidth, dataWidth);
+  });
+  const totalWidth = widths.reduce((sum, w) => sum + w + 3, -1);
+  const separator = "\u251C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524";
+  const topBorder = "\u250C" + "\u2500".repeat(totalWidth) + "\u2510";
+  const titleSeparator = "\u251C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2524";
+  const bottomBorder = "\u2514" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518";
+  console.log(topBorder);
+  if (title) {
+    const titleText = bold2(title);
+    const titlePadding = totalWidth - title.length - 1;
+    const titleRow = "\u2502 " + titleText + " ".repeat(titlePadding) + "\u2502";
+    console.log(titleRow);
+    console.log(titleSeparator);
+  }
+  const header = "\u2502 " + keys.map((key, i) => key.padEnd(widths[i])).join(" \u2502 ") + " \u2502";
+  console.log(header);
+  console.log(separator);
+  rows.forEach((row) => {
+    const dataRow = "\u2502 " + row.map((cell, i) => cell.padEnd(widths[i])).join(" \u2502 ") + " \u2502";
+    console.log(dataRow);
+  });
+  console.log(bottomBorder);
+}
+var logger = {
+  table: (data, title) => {
+    formatTable(data, title);
+  },
+  /**
+   * Info message - general information
+   */
+  info: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${blue("\u2139")} ${bold2(customTransform(message))}`);
+  },
+  /**
+   * Admonition - highlighted note/tip/warning box (Docusaurus-style)
+   */
+  admonition: (type, title, lines, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const configs = {
+      note: { color: green },
+      tip: { color: cyan },
+      info: { color: blue },
+      warning: { color: yellow }
+    };
+    const { color: color2 } = configs[type];
+    console.log(`${spaces}${color2("\u250C\u2500")} ${bold2(color2(title.toUpperCase()))}`);
+    if (lines && lines.length > 0) {
+      lines.forEach((line) => {
+        console.log(`${spaces}${color2("\u2502")} ${customTransform(line)}`);
+      });
+    }
+    console.log(`${spaces}${color2("\u2514\u2500")}`);
+  },
+  /**
+   * Dim message - less important information
+   */
+  dim: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${dim2(customTransform(message))}`);
+  },
+  /**
+   * Success message - operation completed successfully
+   */
+  success: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${green("\u2714")} ${bold2(customTransform(message))}`);
+  },
+  remark: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold2(yellowBright("\u2726"))} ${bold2(customTransform(message))}`);
+  },
+  /**
+   * Error message - operation failed
+   */
+  error: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.error(`${spaces}${red("\u2716")} ${customTransform(message)}`);
+  },
+  bold: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold2(customTransform(message))}`);
+  },
+  /**
+   * Warning message - something to be aware of
+   */
+  warn: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.warn(`${spaces}${yellow("\u26A0")} ${bold2(customTransform(message))}`);
+  },
+  /**
+   * Debug message - only shown when DEBUG env var is set
+   */
+  debug: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    if (process.env.DEBUG) {
+      console.log(gray("[DEBUG]"), `${spaces}${message}`);
+    }
+  },
+  /**
+   * Step message - shows progress through a process
+   */
+  step: (step, total, message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(spaces + cyan(`[${step}/${total}]`), customTransform(message));
+  },
+  /**
+   * Highlighted message - draws attention
+   */
+  highlight: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(bold2(`${spaces}${cyan(customTransform(message))}`));
+  },
+  /**
+   * Aside message - for side information
+   */
+  aside: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold2(customTransform(message))}`);
+  },
+  /**
+   * Data display - for structured data output
+   */
+  data: (label, value, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    if (value !== void 0) {
+      console.log(`${spaces}${dim2(label + ":")} ${bold2(value)}`);
+    } else {
+      console.log(`${spaces}${dim2(label)}`);
+    }
+  },
+  /**
+   * JSON output - pretty-printed JSON
+   */
+  json: (data, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const jsonString = colorize(JSON.stringify(data, null, 2));
+    jsonString.split("\n").forEach((line) => {
+      console.log(`${spaces}${line}`);
+    });
+  },
+  /**
+   * New line
+   */
+  newLine: () => {
+    console.log();
+  },
+  /**
+   * Raw output - no formatting, useful for ASCII art or pre-formatted text
+   */
+  raw: (text, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${text}`);
+  },
+  /**
+   * Display a configuration error with helpful suggestions
+   */
+  configError: (error, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const isConfigError = error && typeof error === "object" && "name" in error && error.name === "ConfigError";
+    if (isConfigError && "message" in error && "field" in error && "suggestion" in error) {
+      const configErr = error;
+      console.error(`${spaces}${red("\u2716")} ${bold2(configErr.message)}`);
+      if (configErr.field) {
+        console.error(`${spaces}  ${dim2("Field:")} ${configErr.field}`);
+      }
+      if (configErr.suggestion) {
+        console.error(`${spaces}  ${dim2("Fix:")} ${configErr.suggestion}`);
+      }
+    } else if (error instanceof Error) {
+      console.error(`${spaces}${red("\u2716")} ${bold2(error.message)}`);
+    } else {
+      console.error(`${spaces}${red("\u2716")} ${bold2(String(error))}`);
+    }
+  }
+};
+
+// src/lib/core/errors.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return "Unknown error";
+}
+
+// ../utils/src/pure/index.ts
+init_package_json();
+
+// src/lib/config/loader.ts
+init_file_loader();
+
+// src/lib/templates/loader.ts
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var currentDir = dirname(fileURLToPath(import.meta.url));
+
+// src/lib/db/reset.ts
+function resetDatabase() {
+  const dbPath = getDevDbPath();
+  const sqlite = new Database2(dbPath);
+  const TURN_FOREIGN_KEYS_OFF_SQL = "PRAGMA foreign_keys = OFF";
+  const TURN_FOREIGN_KEYS_ON_SQL = "PRAGMA foreign_keys = ON";
+  const DROP_ALL_USER_TABLES_SQL = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+  const DROP_TABLE_SQL = (tableName) => `DROP TABLE IF EXISTS ${tableName}`;
+  runStep(
+    "Dropping all tables",
+    async () => {
+      sqlite.prepare(TURN_FOREIGN_KEYS_OFF_SQL).run();
+      const tables = sqlite.prepare(DROP_ALL_USER_TABLES_SQL).all();
+      for (const table of tables) {
+        sqlite.prepare(DROP_TABLE_SQL(table.name)).run();
+      }
+      sqlite.prepare(TURN_FOREIGN_KEYS_ON_SQL).run();
+    },
+    "Dropped all tables"
+  );
+  try {
+    const pm = getPackageManager();
+    const pushCommand = getRunCommand(pm, "db:push");
+    runStep(
+      "Pushing schema",
+      async () => {
+        execSync2(pushCommand, { stdio: ["inherit", "ignore", "inherit"] });
+      },
+      "Pushed schema"
+    );
+    return sqlite;
+  } catch (error) {
+    logger.error(`Failed to push schema: ${getErrorMessage(error)}`);
+    process.exit(1);
+  }
+}
+export {
+  getDevDbPath as getPath,
+  resetDatabase
+};

package/dist/edge-play/src/constants.ts

@@ -2,37 +2,12 @@
  * Constants for game backend workers
  */
 
-/**
- * Environment variables for game backend workers
- */
-export const ENV_VARS = {
-    /** Game-specific API key for calling platform API */
-    PLAYCADEMY_API_KEY: 'PLAYCADEMY_API_KEY',
-    /** Game ID (UUID) */
-    GAME_ID: 'GAME_ID',
-    /** Platform API base URL */
-    PLAYCADEMY_BASE_URL: 'PLAYCADEMY_BASE_URL',
-} as const
-
-/**
- * Worker naming patterns
- * - Production workers: {slug} → accessible at {slug}.playcademy.gg
- * - Staging workers: staging-{slug} → accessible at {slug}-staging.playcademy.gg
- */
-export const WORKER_NAMING = {
-    /** Prefix for staging worker names (e.g., "staging-bamboo") */
-    STAGING_PREFIX: 'staging-',
-    /** Suffix for staging worker hostnames (e.g., "bamboo-staging.playcademy.gg") */
-    STAGING_SUFFIX: '-staging',
-} as const
+import { TIMEBACK_ROUTES, WORKER_ENV_VARS, WORKER_NAMING } from '@playcademy/constants'
 
 /**
- * TimeBack integration route paths
- * These are relative to /api/ - full paths are /api/integrations/timeback/*
+ * Re-export shared constants from @playcademy/constants
  */
-const TIMEBACK_ROUTES = {
-    END_ACTIVITY: '/integrations/timeback/end-activity',
-} as const
+export { WORKER_ENV_VARS as ENV_VARS, WORKER_NAMING }
 
 /**
  * Built-in API routes