@playcademy/vite-plugin 0.1.12 → 0.1.14

package/dist/index.js

@@ -124995,7 +124995,7 @@ var logger = (fn = console.log) => {
 };
 var package_default = {
   name: "@playcademy/sandbox",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "Local development server for Playcademy game development",
   type: "module",
   exports: {
@@ -125032,7 +125032,6 @@ var package_default = {
   dependencies: {
     "@electric-sql/pglite": "^0.3.2",
     "@hono/node-server": "^1.14.2",
-    "@playcademy/constants": "workspace:*",
     commander: "^12.1.0",
     "drizzle-kit": "^0.31.0",
     "drizzle-orm": "^0.42.0",
@@ -169636,6 +169635,92 @@ import {
   startPlaycademyDevServer,
   startPlaycademyHotReload
 } from "playcademy/utils";
+
+// ../utils/src/port.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+async function isPortAvailableOnHost(port, host) {
+  return new Promise((resolve2) => {
+    const server = createServer();
+    server.once("error", () => {
+      resolve2(false);
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve2(true);
+    });
+    server.listen(port, host);
+  });
+}
+async function findAvailablePort(startPort = 4321) {
+  const ipv4AllAvailable = await isPortAvailableOnHost(startPort, "0.0.0.0");
+  const ipv6AllAvailable = await isPortAvailableOnHost(startPort, "::");
+  if (ipv4AllAvailable && ipv6AllAvailable) {
+    return startPort;
+  }
+  return findAvailablePort(startPort + 1);
+}
+function getRegistryPath() {
+  const home = homedir();
+  const dir = join3(home, ".playcademy");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return join3(dir, ".proc");
+}
+function readRegistry() {
+  const registryPath = getRegistryPath();
+  if (!existsSync2(registryPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(registryPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeRegistry(registry) {
+  const registryPath = getRegistryPath();
+  writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+}
+function getServerKey(type, port) {
+  return `${type}-${port}`;
+}
+function writeServerInfo(type, info2) {
+  const registry = readRegistry();
+  const key = getServerKey(type, info2.port);
+  registry[key] = info2;
+  writeRegistry(registry);
+}
+function cleanupServerInfo(type, projectRoot, pid) {
+  const registry = readRegistry();
+  const keysToRemove = [];
+  for (const [key, info2] of Object.entries(registry)) {
+    if (key.startsWith(`${type}-`)) {
+      let matches = true;
+      if (projectRoot && info2.projectRoot !== projectRoot) {
+        matches = false;
+      }
+      if (pid !== undefined && info2.pid !== pid) {
+        matches = false;
+      }
+      if (matches) {
+        keysToRemove.push(key);
+      }
+    }
+  }
+  for (const key of keysToRemove) {
+    delete registry[key];
+  }
+  if (keysToRemove.length > 0) {
+    writeRegistry(registry);
+  }
+}
+
+// src/lib/cli-server.ts
 async function tryLoadConfig(viteConfig) {
   try {
     return await loadConfig2();
@@ -169689,19 +169774,22 @@ function setupHotReload(serverRef, options, viteConfig) {
   return () => watcher.close();
 }
 async function setupCliDevServer(options) {
-  const { port, viteConfig, platformUrl } = options;
+  const { preferredPort, viteConfig, platformUrl } = options;
   const config2 = await tryLoadConfig(viteConfig);
   if (!config2)
     return null;
   if (!needsCliDevServer(config2))
     return null;
   try {
+    const port = await findAvailablePort(preferredPort);
     const serverOptions = { port, config: config2, platformUrl };
     const serverRef = { current: await startServer2(serverOptions) };
     const stopHotReload = setupHotReload(serverRef, serverOptions, viteConfig);
     return {
       server: serverRef.current,
-      stopHotReload
+      port,
+      stopHotReload,
+      cleanup: () => cleanupServerInfo("backend", viteConfig.root, process.pid)
     };
   } catch (error2) {
     viteConfig.logger.error(`Failed to start game backend: ${error2 instanceof Error ? error2.message : String(error2)}`);
@@ -169769,20 +169857,6 @@ function formatNumberWithCommas(numStr) {
   parts2[0] = parts2[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   return parts2.join(".");
 }
-async function findAvailablePort(startPort = 4321) {
-  const { createServer } = await import("node:net");
-  return new Promise((resolve2, reject) => {
-    const server = createServer();
-    server.listen(startPort, () => {
-      const address = server.address();
-      const port = address && typeof address === "object" ? address.port : startPort;
-      server.close(() => resolve2(port));
-    });
-    server.on("error", () => {
-      findAvailablePort(startPort + 1).then(resolve2).catch(reject);
-    });
-  });
-}
 
 // src/lib/manifest.ts
 var LOG_LINE_TOTAL_WIDTH = 60;
@@ -169924,6 +169998,7 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
     return {
       baseUrl,
       realtimeUrl: deriveRealtimeUrl(baseUrl),
+      port: DEFAULT_PORTS.SANDBOX,
       project: null,
       cleanup: () => {}
     };
@@ -169942,6 +170017,13 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
       realtime: { enabled: false, port: realtimePort },
       timeback: timebackOptions
     });
+    writeServerInfo("sandbox", {
+      pid: process.pid,
+      port: sandboxPort,
+      url: baseUrl,
+      startedAt: Date.now(),
+      projectRoot: viteConfig.root
+    });
     if (!quiet) {
       setTimeout(() => {
         printSandboxInfo(viteConfig, sandboxPort, realtimePort, projectInfo);
@@ -169950,11 +170032,12 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
     return {
       baseUrl,
       realtimeUrl,
+      port: sandboxPort,
       project: projectInfo,
       cleanup: () => {
+        cleanupServerInfo("sandbox", viteConfig.root, process.pid);
         if (server && typeof server.stop === "function") {
           server.stop();
-          viteConfig.logger.info(import_picocolors4.default.yellow("[Playcademy] Sandbox server stopped"));
         }
       }
     };
@@ -169963,6 +170046,7 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
     return {
       baseUrl: `http://localhost:${DEFAULT_PORTS.SANDBOX}`,
       realtimeUrl: "ws://localhost:4322",
+      port: DEFAULT_PORTS.SANDBOX,
       project: null,
       cleanup: () => {}
     };
@@ -170435,6 +170519,27 @@ function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
 }
 
 // src/index.ts
+function setupDevServerCleanup(getSandbox, getBackend) {
+  let isShuttingDown = false;
+  const cleanup = () => {
+    if (isShuttingDown)
+      return;
+    isShuttingDown = true;
+    const sandbox = getSandbox();
+    const backend = getBackend();
+    if (sandbox)
+      sandbox.cleanup();
+    if (backend) {
+      backend.server.dispose();
+      backend.stopHotReload();
+      backend.cleanup();
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  return cleanup;
+}
 function playcademy(options = {}) {
   let viteConfig;
   let currentBuildOutputs = {};
@@ -170462,34 +170567,34 @@ function playcademy(options = {}) {
       currentBuildOutputs = {};
     },
     async configureServer(server) {
+      const serverRefs = {
+        sandbox: null,
+        backend: null
+      };
+      const cleanup = setupDevServerCleanup(() => serverRefs.sandbox, () => serverRefs.backend);
       const sandbox = await startSandbox(viteConfig, _options.startSandbox, {
         verbose: _options.verbose,
         customUrl: _options.sandboxUrl,
         quiet: true
       });
+      serverRefs.sandbox = sandbox;
       const backend = await setupCliDevServer({
-        port: DEFAULT_PORTS2.BACKEND,
+        preferredPort: DEFAULT_PORTS2.BACKEND,
         viteConfig,
         platformUrl: sandbox.baseUrl
       });
+      serverRefs.backend = backend;
       if (sandbox.project) {
-        const gameUrl = backend ? `http://localhost:${DEFAULT_PORTS2.BACKEND}` : undefined;
+        const gameUrl = backend ? `http://localhost:${backend.port}` : undefined;
         devServerMiddleware(server, sandbox, gameUrl, _options.showBadge);
       }
       server.httpServer?.once("listening", () => {
         setTimeout(() => {
           const projectInfo = extractProjectInfo(viteConfig);
-          printBanner(viteConfig, {
-            sandbox: DEFAULT_PORTS2.SANDBOX,
-            backend: backend ? DEFAULT_PORTS2.BACKEND : undefined
-          }, projectInfo, version3);
+          printBanner(viteConfig, { sandbox: sandbox.port, backend: backend?.port }, projectInfo, version3);
         }, 100);
       });
-      server.httpServer?.on("close", () => {
-        sandbox.cleanup();
-        backend?.server.dispose();
-        backend?.stopHotReload();
-      });
+      server.httpServer?.on("close", cleanup);
     },
     async writeBundle() {
       const outDir = viteConfig.build.outDir || path4.join(process.cwd(), "dist");

package/dist/types.d.ts

@@ -72,6 +72,7 @@ export interface ManifestOptions {
 export interface SandboxManager {
     baseUrl: string;
     realtimeUrl: string;
+    port: number;
     project: ProjectInfo | null;
     cleanup: () => void;
 }
@@ -82,13 +83,15 @@ export interface CliServerManager {
     server: {
         dispose: () => Promise<void>;
     };
+    port: number;
     stopHotReload: () => void;
+    cleanup: () => void;
 }
 /**
  * Options for setting up the CLI dev server
  */
 export interface CliDevServerOptions {
-    port: number;
+    preferredPort: number;
     viteConfig: ResolvedConfig;
     platformUrl?: string;
 }

package/dist/utils.d.ts

@@ -5,4 +5,3 @@ import type { ResolvedConfig } from 'vite';
 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.1.12",
+    "version": "0.1.14",
     "type": "module",
     "exports": {
         ".": {
@@ -25,11 +25,11 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.13.2"
+        "playcademy": "0.13.5"
     },
     "devDependencies": {
         "@inquirer/prompts": "^7.8.6",
-        "@playcademy/sandbox": "0.1.1",
+        "@playcademy/sandbox": "0.1.3",
         "@types/archiver": "^6.0.3",
         "@types/bun": "latest",
         "yocto-spinner": "^0.2.2"