@playcademy/vite-plugin 0.1.26-alpha.1 → 0.1.26-alpha.2

package/dist/index.js

@@ -41138,11 +41138,25 @@ import { DEFAULT_PORTS as DEFAULT_PORTS3 } from "playcademy/constants";
 // src/server/state.ts
 var serverState = {
   sandbox: null,
-  backend: null
+  backend: null,
+  viteServer: null,
+  currentMode: "platform"
 };
 function hasActiveServers() {
   return !!(serverState.backend || serverState.sandbox);
 }
+function getCurrentMode() {
+  return serverState.currentMode;
+}
+function setCurrentMode(mode) {
+  serverState.currentMode = mode;
+}
+function getViteServerRef() {
+  return serverState.viteServer;
+}
+function setViteServerRef(server) {
+  serverState.viteServer = server;
+}
 
 // src/server/cleanup.ts
 async function cleanupServers() {
@@ -41179,10 +41193,13 @@ function setupProcessShutdownHandlers() {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
+
+// src/server/mode-switcher.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "0.1.25",
+  version: "0.1.26",
   type: "module",
   exports: {
     ".": {
@@ -41197,8 +41214,8 @@ var package_default = {
   ],
   scripts: {
     build: "rm -rf dist && bun build.ts",
-    pub: "bun publish.ts",
-    docs: "typedoc --skipErrorChecking"
+    docs: "typedoc --skipErrorChecking",
+    pub: "bun publish.ts"
   },
   dependencies: {
     archiver: "^7.0.1",
@@ -205912,6 +205929,10 @@ function generateLoaderHTML(sandboxUrl, gameId, realtimeUrl, showBadge, gameUrl)
 }
 function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
   server.middlewares.use("/", (req, res, next) => {
+    if (getCurrentMode() !== "platform") {
+      next();
+      return;
+    }
     if (req.url === "/" && req.method === "GET") {
       const secFetchDest = req.headers["sec-fetch-dest"];
       if (secFetchDest === "iframe") {
@@ -205979,28 +206000,77 @@ async function configureStandaloneMode(server, viteConfig, preferredPort) {
   });
 }
 
+// src/server/mode-switcher.ts
+async function toggleMode(options) {
+  const currentMode = getCurrentMode();
+  const newMode = currentMode === "platform" ? "standalone" : "platform";
+  const viteServer = getViteServerRef();
+  if (!viteServer) {
+    options.viteConfig.logger.error("[Playcademy] Cannot toggle mode: no Vite server reference");
+    return;
+  }
+  options.viteConfig.logger.info("");
+  options.viteConfig.logger.info(import_picocolors7.default.yellow(`Switching from ${import_picocolors7.default.bold(currentMode)} to ${import_picocolors7.default.bold(newMode)} mode...`));
+  options.viteConfig.logger.info("");
+  await cleanupServers();
+  await new Promise((resolve2) => setTimeout(resolve2, 100));
+  setCurrentMode(newMode);
+  if (newMode === "standalone") {
+    await configureStandaloneMode(viteServer, options.viteConfig, options.platformModeOptions.preferredBackendPort);
+  } else {
+    await configurePlatformMode(viteServer, options.viteConfig, options.platformModeOptions);
+  }
+  options.viteConfig.logger.info("");
+  options.viteConfig.logger.info(import_picocolors7.default.green(`✓ Switched to ${import_picocolors7.default.bold(newMode)} mode`));
+  options.viteConfig.logger.info("");
+}
+
 // src/hooks/configure-server.ts
 async function configureServerHook(server, context) {
   if (!context.viteConfig) {
     throw new Error("[Playcademy] Vite config not resolved before configureServer");
   }
+  setViteServerRef(server);
+  setCurrentMode(context.options.mode);
   setupProcessShutdownHandlers();
   if (hasActiveServers()) {
     await cleanupServers();
     await new Promise((resolve2) => setTimeout(resolve2, 100));
   }
   const preferredPort = context.backendPort ?? DEFAULT_PORTS3.BACKEND;
+  const platformModeOptions = {
+    startSandbox: context.options.startSandbox,
+    verbose: context.options.verbose,
+    sandboxUrl: context.options.sandboxUrl,
+    recreateDb: context.options.recreateDb,
+    showBadge: context.options.showBadge,
+    preferredBackendPort: preferredPort
+  };
   if (context.options.mode === "standalone") {
     await configureStandaloneMode(server, context.viteConfig, preferredPort);
   } else {
-    await configurePlatformMode(server, context.viteConfig, {
-      startSandbox: context.options.startSandbox,
-      verbose: context.options.verbose,
-      sandboxUrl: context.options.sandboxUrl,
-      recreateDb: context.options.recreateDb,
-      showBadge: context.options.showBadge,
-      preferredBackendPort: preferredPort
-    });
+    await configurePlatformMode(server, context.viteConfig, platformModeOptions);
+  }
+  const originalBindCLIShortcuts = server.bindCLIShortcuts?.bind(server);
+  if (originalBindCLIShortcuts) {
+    server.bindCLIShortcuts = (options) => {
+      originalBindCLIShortcuts({
+        ...options,
+        customShortcuts: [
+          ...options?.customShortcuts || [],
+          {
+            key: "m",
+            description: "toggle platform/standalone mode",
+            action: async () => {
+              await toggleMode({
+                viteConfig: context.viteConfig,
+                platformModeOptions
+              });
+            }
+          }
+        ]
+      });
+    };
   }
 }
 

package/dist/server/mode-switcher.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mode switching functionality
+ * Handles toggling between platform and standalone modes
+ */
+import type { ResolvedConfig } from 'vite';
+import type { PlatformModeOptions } from './platform-mode';
+export interface ModeSwitcherOptions {
+    viteConfig: ResolvedConfig;
+    platformModeOptions: PlatformModeOptions;
+}
+/**
+ * Toggle between platform and standalone modes
+ */
+export declare function toggleMode(options: ModeSwitcherOptions): Promise<void>;

package/dist/server/state.d.ts

@@ -6,13 +6,17 @@
  * but the servers continue running in the same Node process. We maintain
  * these references at module scope to properly clean them up on restart.
  */
+import type { ViteDevServer } from 'vite';
 import type { CliServerManager, SandboxManager } from '../types';
+import type { PlaycademyMode } from '../types/options';
 /**
  * Module-level server references
  */
 export declare const serverState: {
     sandbox: SandboxManager | null;
     backend: CliServerManager | null;
+    viteServer: ViteDevServer | null;
+    currentMode: PlaycademyMode;
 };
 /**
  * Get sandbox server reference
@@ -34,3 +38,19 @@ export declare function setBackendRef(backend: CliServerManager | null): void;
  * Check if any servers are currently running
  */
 export declare function hasActiveServers(): boolean;
+/**
+ * Get current mode
+ */
+export declare function getCurrentMode(): PlaycademyMode;
+/**
+ * Set current mode
+ */
+export declare function setCurrentMode(mode: PlaycademyMode): void;
+/**
+ * Get Vite dev server reference
+ */
+export declare function getViteServerRef(): ViteDevServer | null;
+/**
+ * Set Vite dev server reference
+ */
+export declare function setViteServerRef(server: ViteDevServer | null): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.1.26-alpha.1",
+    "version": "0.1.26-alpha.2",
     "type": "module",
     "exports": {
         ".": {
@@ -15,8 +15,8 @@
     ],
     "scripts": {
         "build": "rm -rf dist && bun build.ts",
-        "pub": "bun publish.ts",
-        "docs": "typedoc --skipErrorChecking"
+        "docs": "typedoc --skipErrorChecking",
+        "pub": "bun publish.ts"
     },
     "dependencies": {
         "archiver": "^7.0.1",