@playcademy/vite-plugin 0.1.8 → 0.1.10

package/dist/index.js

@@ -169556,32 +169556,37 @@ var version3 = package_default.version;
 
 // src/lib/cli-server.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
-import { startPlaycademyDevServer, startPlaycademyHotReload } from "playcademy/utils";
+import {
+  loadPlaycademyConfig as loadConfig2,
+  startPlaycademyDevServer,
+  startPlaycademyHotReload
+} from "playcademy/utils";
+async function tryLoadConfig(viteConfig) {
+  try {
+    return await loadConfig2();
+  } catch (error2) {
+    if (error2 instanceof Error && !error2.message.includes("Could not find")) {
+      viteConfig.logger.warn(`Could not load playcademy.config.js: ${error2.message}`);
+    }
+    return null;
+  }
+}
 function needsCliDevServer(config2) {
-  if (config2.integrations)
-    return true;
-  return false;
+  return !!config2.integrations;
 }
-async function startCliDevServer(options) {
-  const { port, config: config2, viteConfig, platformUrl } = options;
-  let server = await startPlaycademyDevServer({
-    port,
-    config: config2,
-    quiet: true,
-    platformUrl
-  });
-  const watcher = startPlaycademyHotReload(async () => {
-    await server.dispose();
-    server = await startPlaycademyDevServer({
-      port,
-      config: config2,
-      quiet: true,
-      platformUrl
-    });
-  }, {
+function formatChangedPath(changedPath) {
+  if (!changedPath)
+    return;
+  if (changedPath.includes("/api/")) {
+    return changedPath.substring(changedPath.indexOf("/api/"));
+  }
+  return changedPath;
+}
+function createHotReloadCallbacks(viteConfig) {
+  return {
     onSuccess: (changedPath) => {
-      if (changedPath) {
-        const relativePath = changedPath.includes("/api/") ? changedPath.substring(changedPath.indexOf("/api/")) : changedPath;
+      const relativePath = formatChangedPath(changedPath);
+      if (relativePath) {
         viteConfig.logger.info(`${import_picocolors.dim("(backend)")} ${import_picocolors.green("hmr update")} ${import_picocolors.dim(relativePath)}`, { timestamp: true });
       } else {
         viteConfig.logger.info("backend reloaded", { timestamp: true });
@@ -169590,12 +169595,44 @@ async function startCliDevServer(options) {
     onError: (error2) => {
       viteConfig.logger.error(`backend reload failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
-  });
-  return {
-    server,
-    stopHotReload: () => watcher.close()
   };
 }
+async function startServer2(options) {
+  const { port, config: config2, platformUrl } = options;
+  return startPlaycademyDevServer({
+    port,
+    config: config2,
+    quiet: true,
+    platformUrl
+  });
+}
+function setupHotReload(serverRef, options, viteConfig) {
+  const watcher = startPlaycademyHotReload(async () => {
+    await serverRef.current.dispose();
+    serverRef.current = await startServer2(options);
+  }, createHotReloadCallbacks(viteConfig));
+  return () => watcher.close();
+}
+async function setupCliDevServer(options) {
+  const { port, viteConfig, platformUrl } = options;
+  const config2 = await tryLoadConfig(viteConfig);
+  if (!config2)
+    return null;
+  if (!needsCliDevServer(config2))
+    return null;
+  try {
+    const serverOptions = { port, config: config2, platformUrl };
+    const serverRef = { current: await startServer2(serverOptions) };
+    const stopHotReload = setupHotReload(serverRef, serverOptions, viteConfig);
+    return {
+      server: serverRef.current,
+      stopHotReload
+    };
+  } catch (error2) {
+    viteConfig.logger.error(`Failed to start game backend: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    return null;
+  }
+}
 
 // src/lib/logging.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
@@ -169621,7 +169658,6 @@ import path3 from "node:path";
 // src/utils.ts
 import fs4 from "node:fs";
 import path2 from "node:path";
-import { loadPlaycademyConfig as loadConfig2 } from "playcademy/utils";
 function extractProjectInfo(viteConfig) {
   const projectRoot = viteConfig.root;
   const directoryName = path2.basename(projectRoot);
@@ -169672,20 +169708,6 @@ async function findAvailablePort(startPort = 4321) {
     });
   });
 }
-async function loadPlaycademyConfig(viteConfig) {
-  const projectRoot = viteConfig.root;
-  const configPath = path2.join(projectRoot, "playcademy.config.js");
-  try {
-    if (fs4.existsSync(configPath)) {
-      return await loadConfig2(configPath);
-    }
-  } catch (error2) {
-    viteConfig.logger.error(`Failed to load playcademy.config.js: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    viteConfig.logger.error(`configPath: ${configPath}`);
-    throw error2;
-  }
-  return null;
-}
 
 // src/lib/manifest.ts
 var LOG_LINE_TOTAL_WIDTH = 60;
@@ -170341,7 +170363,6 @@ function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
 function playcademy(options = {}) {
   let viteConfig;
   let currentBuildOutputs = {};
-  let playcademyConfig = null;
   const exportOptions = options.export ?? {};
   const sandboxOptions = options.sandbox ?? {};
   const devOptions = options.dev ?? {};
@@ -170364,7 +170385,6 @@ function playcademy(options = {}) {
     async configResolved(resolvedConfig) {
       viteConfig = resolvedConfig;
       currentBuildOutputs = {};
-      playcademyConfig = await loadPlaycademyConfig(resolvedConfig);
     },
     async configureServer(server) {
       const sandbox = await startSandbox(viteConfig, _options.startSandbox, {
@@ -170372,21 +170392,13 @@ function playcademy(options = {}) {
         customUrl: _options.sandboxUrl,
         quiet: true
       });
-      let cliServerManager = null;
-      if (playcademyConfig && needsCliDevServer(playcademyConfig)) {
-        try {
-          cliServerManager = await startCliDevServer({
-            port: DEFAULT_PORTS2.BACKEND,
-            config: playcademyConfig,
-            viteConfig,
-            platformUrl: sandbox.baseUrl
-          });
-        } catch (error2) {
-          viteConfig.logger.error(`Failed to start game backend: ${error2}`);
-        }
-      }
+      const backend = await setupCliDevServer({
+        port: DEFAULT_PORTS2.BACKEND,
+        viteConfig,
+        platformUrl: sandbox.baseUrl
+      });
       if (sandbox.project) {
-        const gameUrl = cliServerManager ? `http://localhost:${DEFAULT_PORTS2.BACKEND}` : undefined;
+        const gameUrl = backend ? `http://localhost:${DEFAULT_PORTS2.BACKEND}` : undefined;
         devServerMiddleware(server, sandbox, gameUrl, _options.showBadge);
       }
       server.httpServer?.once("listening", () => {
@@ -170394,16 +170406,14 @@ function playcademy(options = {}) {
           const projectInfo = extractProjectInfo(viteConfig);
           printBanner(viteConfig, {
             sandbox: DEFAULT_PORTS2.SANDBOX,
-            backend: cliServerManager ? DEFAULT_PORTS2.BACKEND : undefined
+            backend: backend ? DEFAULT_PORTS2.BACKEND : undefined
           }, projectInfo, version3);
         }, 100);
       });
       server.httpServer?.on("close", () => {
         sandbox.cleanup();
-        if (cliServerManager) {
-          cliServerManager.server.dispose();
-          cliServerManager.stopHotReload();
-        }
+        backend?.server.dispose();
+        backend?.stopHotReload();
       });
     },
     async writeBundle() {

package/dist/lib/cli-server.d.ts

@@ -1,27 +1,9 @@
-import { startPlaycademyDevServer } from 'playcademy/utils';
-import type { PlaycademyConfig } from 'playcademy/types';
-import type { ResolvedConfig } from 'vite';
+import type { CliDevServerOptions, CliServerManager } from '../types';
 /**
- * Determines if the CLI dev server is needed based on configuration.
- * Checks for integrations or custom routes that require the game backend.
+ * Sets up the CLI dev server with hot reload enabled.
+ * Loads config, checks if backend is needed, and starts server if appropriate.
+ * Returns null if no config or no integrations (backend not needed).
  *
- * @param config - Playcademy configuration
- * @returns True if CLI dev server is needed
- */
-export declare function needsCliDevServer(config: PlaycademyConfig): boolean;
-interface CliServerManager {
-    server: Awaited<ReturnType<typeof startPlaycademyDevServer>>;
-    stopHotReload: () => void;
-}
-export interface CliDevServerOptions {
-    port: number;
-    config: PlaycademyConfig;
-    viteConfig: ResolvedConfig;
-    platformUrl?: string;
-}
-/**
- * Starts the CLI dev server with hot reload enabled.
  * Used by the Vite plugin to manage the game backend server.
  */
-export declare function startCliDevServer(options: CliDevServerOptions): Promise<CliServerManager>;
-export {};
+export declare function setupCliDevServer(options: CliDevServerOptions): Promise<CliServerManager | null>;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Type definitions for the Playcademy Vite Plugin
  */
+import type { ResolvedConfig } from 'vite';
 import type { ManifestV1 } from '@playcademy/data/types';
 /**
  * Project information extracted from package.json and directory structure
@@ -74,3 +75,20 @@ export interface SandboxManager {
     project: ProjectInfo | null;
     cleanup: () => void;
 }
+/**
+ * CLI server manager interface for controlling backend server lifecycle
+ */
+export interface CliServerManager {
+    server: {
+        dispose: () => Promise<void>;
+    };
+    stopHotReload: () => void;
+}
+/**
+ * Options for setting up the CLI dev server
+ */
+export interface CliDevServerOptions {
+    port: number;
+    viteConfig: ResolvedConfig;
+    platformUrl?: string;
+}

package/dist/utils.d.ts

@@ -2,15 +2,7 @@
  * Utility functions for the Playcademy Vite plugin
  */
 import type { ResolvedConfig } from 'vite';
-import type { PlaycademyConfig } from '@playcademy/sdk/server';
 import type { ProjectInfo } from './types';
 export declare function extractProjectInfo(viteConfig: ResolvedConfig): ProjectInfo;
 export declare function formatNumberWithCommas(numStr: string): string;
 export declare function findAvailablePort(startPort?: number): Promise<number>;
-/**
- * Loads the Playcademy configuration from the project root.
- *
- * @param viteConfig - Vite resolved configuration
- * @returns Playcademy configuration or null if not found
- */
-export declare function loadPlaycademyConfig(viteConfig: ResolvedConfig): Promise<PlaycademyConfig | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.1.8",
+    "version": "0.1.10",
     "type": "module",
     "exports": {
         ".": {
@@ -25,7 +25,7 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.12.2"
+        "playcademy": "0.12.9"
     },
     "devDependencies": {
         "@inquirer/prompts": "^7.8.6",