@playcademy/vite-plugin 0.1.9 → 0.1.11

package/dist/index.js

@@ -158087,7 +158087,10 @@ class CloudflareProvider {
         namespace: this.config.dispatchNamespace
       });
       if (deleteBindings) {
-        await this.deleteD1DatabaseIfExists(deploymentId);
+        await Promise.all([
+          this.deleteD1DatabaseIfExists(deploymentId),
+          this.deleteKVNamespaceIfExists(deploymentId)
+        ]);
       }
     } catch (error2) {
       log2.error("[CloudflareProvider] Deletion from dispatch namespace failed", {
@@ -158138,7 +158141,12 @@ class CloudflareProvider {
       }
     }
     for (const kvName of resourceBindings.kv) {
-      log2.warn("[CloudflareProvider] KV namespace binding not yet implemented", { kvName });
+      const namespaceId = await this.ensureKVNamespace(kvName);
+      bindings.push({
+        type: "kv_namespace",
+        name: "KV",
+        namespace_id: namespaceId
+      });
     }
     for (const r2Name of resourceBindings.r2) {
       log2.warn("[CloudflareProvider] R2 bucket binding not yet implemented", { r2Name });
@@ -158250,6 +158258,73 @@ class CloudflareProvider {
       throw new Error(`Failed to execute schema: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
+  async ensureKVNamespace(namespaceName) {
+    log2.debug("[CloudflareProvider] Ensuring KV namespace exists", { namespaceName });
+    try {
+      const namespaces = await this.client.kv.namespaces.list({
+        account_id: this.config.accountId
+      });
+      for await (const ns of namespaces) {
+        if (ns.title === namespaceName && ns.id) {
+          log2.info("[CloudflareProvider] KV namespace already exists", {
+            namespaceName,
+            namespaceId: ns.id
+          });
+          return ns.id;
+        }
+      }
+      log2.debug("[CloudflareProvider] Creating new KV namespace", { namespaceName });
+      const createResult = await this.client.kv.namespaces.create({
+        account_id: this.config.accountId,
+        title: namespaceName
+      });
+      if (!createResult.id) {
+        throw new Error("KV namespace creation succeeded but no ID returned");
+      }
+      log2.info("[CloudflareProvider] KV namespace created successfully", {
+        namespaceName,
+        namespaceId: createResult.id
+      });
+      return createResult.id;
+    } catch (error2) {
+      log2.error("[CloudflareProvider] Failed to ensure KV namespace", {
+        namespaceName,
+        error: error2
+      });
+      throw new Error(`Failed to ensure KV namespace: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  }
+  async deleteKVNamespaceIfExists(namespaceName) {
+    try {
+      const namespaces = await this.client.kv.namespaces.list({
+        account_id: this.config.accountId
+      });
+      for await (const ns of namespaces) {
+        if (ns.title === namespaceName && ns.id) {
+          log2.debug("[CloudflareProvider] Deleting KV namespace", {
+            namespaceName,
+            namespaceId: ns.id
+          });
+          await this.client.kv.namespaces.delete(ns.id, {
+            account_id: this.config.accountId
+          });
+          log2.info("[CloudflareProvider] KV namespace deleted successfully", {
+            namespaceName,
+            namespaceId: ns.id
+          });
+          return;
+        }
+      }
+      log2.debug("[CloudflareProvider] KV namespace not found, nothing to delete", {
+        namespaceName
+      });
+    } catch (error2) {
+      log2.warn("[CloudflareProvider] Failed to delete KV namespace", {
+        namespaceName,
+        error: error2
+      });
+    }
+  }
 }
 var RESERVED_SUBDOMAINS = new Set([
   "www",
@@ -169556,32 +169631,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 +169670,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 +169733,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 +169783,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 +170438,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 +170460,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 +170467,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 +170481,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.9",
+    "version": "0.1.11",
     "type": "module",
     "exports": {
         ".": {