@lobb-js/core 0.13.3 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobb-js/core",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "publishConfig": {

package/src/Lobb.ts

@@ -59,7 +59,6 @@ export class Lobb {
       };
     }
 
-    console.log("starting the app");
     const lobb = new Lobb();
     lobb.studio = studio;
     lobb.tempDatabase = isTempDatabase;
@@ -79,7 +78,7 @@ export class Lobb {
     lobb.schemaService = await SchemaService.init();
     const webPort = lobb.configManager.config.web_server.port ?? 3000;
     const studioPort = await studio.start(webPort);
-    lobb.webServer = await WebServer.init(studioPort);
+    lobb.webServer = await WebServer.init(studio.devPort !== null ? null : studioPort);
     lobb.collectionControllers = collectionControllers;
     lobb.transactions = transactions;
     await lobb.extensionSystem.executeExtensionsInitMethods();
@@ -90,7 +89,7 @@ export class Lobb {
     // generate types
     lobb.typesGenerator = await TypesGenerator.init();
 
-    console.log("The app is running");
+    console.log(`The app is running on http://localhost:${studioPort ?? lobb.webServer.port}`);
 
     return lobb;
   }

package/src/api/WebServer.ts

@@ -74,53 +74,11 @@ export class WebServer {
       this.app.all("/studio/*", studioProxy);
     }
 
-    const isDev = process.env.LOBB_MODE !== "prod";
-    const serveBase = {
+    this.server = Bun.serve({
       port: this.webConfig.port ?? 3000,
       hostname: this.webConfig.host ?? "0.0.0.0",
-    };
-
-    // In dev, forward WebSocket upgrade requests to the Vite dev server so that
-    // Vite's HMR can connect through the Lobb proxy instead of falling back to
-    // a direct connection (which causes a console warning).
-    if (isDev && studioPort) {
-      type WSData = { path: string; upstream?: WebSocket };
-      this.server = Bun.serve<WSData>({
-        ...serveBase,
-        fetch: (req, server) => {
-          if (req.headers.get("upgrade") === "websocket") {
-            const url = new URL(req.url);
-            if (url.pathname.startsWith("/studio")) {
-              const upgraded = server.upgrade(req, { data: { path: url.pathname + url.search } });
-              if (upgraded) return undefined;
-            }
-          }
-          return this.app.fetch(req);
-        },
-        websocket: {
-          open(ws) {
-            const upstream = new WebSocket(`ws://localhost:${studioPort}${ws.data.path.replace(/^\/studio/, "") || "/"}`);
-            ws.data.upstream = upstream;
-            upstream.addEventListener("message", (e) => ws.send(e.data as string | ArrayBuffer));
-            upstream.addEventListener("close", (e) => ws.close(e.code, e.reason));
-            upstream.addEventListener("error", () => ws.close());
-          },
-          message(ws, message) {
-            if (ws.data.upstream?.readyState === WebSocket.OPEN) {
-              ws.data.upstream.send(message as string | ArrayBuffer);
-            }
-          },
-          close(ws, code, reason) {
-            ws.data.upstream?.close(code, reason);
-          },
-        },
-      });
-    } else {
-      this.server = Bun.serve({
-        ...serveBase,
-        fetch: this.app.fetch,
-      });
-    }
+      fetch: this.app.fetch,
+    });
     this.port = this.server.port!;
   }
 }

package/src/studio/Studio.ts

@@ -7,6 +7,7 @@ import type { AddressInfo } from "node:net";
 export class Studio {
   private studioDir: string;
   private process: ReturnType<typeof Bun.spawn> | null = null;
+  public devPort: number | null = null;
 
   constructor(projectDir: string) {
     // Support flat structure (vite.config.ts at project root) and nested (studio/ subdir).
@@ -21,24 +22,17 @@ export class Studio {
   }
 
   public async start(webPort: number): Promise<number | null> {
+    if (this.process) return null;
     if (!await this.exists()) return null;
 
-    const mode = process.env.LOBB_MODE;
-
-    if (mode === "prod") {
-      const buildDir = `${this.studioDir}/build`;
-      try {
-        const s = await stat(buildDir);
-        if (!s.isDirectory()) throw new Error();
-      } catch {
-        throw new Error(
-          "Studio build not found. Run 'bun run build:studio' before starting in production mode."
-        );
-      }
-      return await this.serveBuild(webPort);
-    }
+    const buildDir = `${this.studioDir}/build`;
+    try {
+      const s = await stat(buildDir);
+      if (s.isDirectory()) return await this.serveBuild(webPort);
+    } catch {}
 
-    return await this.runDevServer(webPort);
+    await this.runDevServer(webPort);
+    return this.devPort;
   }
 
   private async exists(): Promise<boolean> {
@@ -51,13 +45,12 @@ export class Studio {
   }
 
   private async serveBuild(webPort: number): Promise<number> {
-    console.log("Studio: running production build.");
     const port = await Studio.getFreePort();
     this.process = Bun.spawn(["bun", "run", "build/index.js"], {
       cwd: this.studioDir,
       env: { ...process.env, PORT: String(port) },
-      stdin: "pipe",
-      stdout: "inherit",
+      stdin: "ignore",
+      stdout: "ignore",
       stderr: "inherit",
     });
     await Studio.waitForPort(port);
@@ -65,19 +58,18 @@ export class Studio {
     return port;
   }
 
-  private async runDevServer(webPort: number): Promise<number> {
-    const port = await Studio.getFreePort();
-    console.log("Studio: running dev server.");
-    this.process = Bun.spawn(["bun", "run", "dev:studio", "--port", String(port)], {
-      cwd: this.studioDir,
-      env: { ...process.env },
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "inherit",
-    });
-    await Studio.waitForPort(port);
-    console.log(`Studio: http://localhost:${webPort}/studio`);
-    return port;
+  private async runDevServer(webPort: number): Promise<void> {
+    this.devPort = await Studio.getAvailablePort(5173);
+    this.process = Bun.spawn(
+      ["bun", "run", "dev:studio", "--", "--port", String(this.devPort)],
+      {
+        cwd: this.studioDir,
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "inherit",
+        env: { ...process.env, LOBB_PORT: String(webPort) },
+      }
+    );
   }
 
   private static getFreePort(): Promise<number> {
@@ -93,6 +85,24 @@ export class Studio {
     });
   }
 
+  // Like Vite's port resolution: try preferred port, increment on conflict.
+  // Predictable ports preserve browser sessions across restarts.
+  private static getAvailablePort(preferred: number): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const server = createServer();
+      server.listen(preferred, "127.0.0.1", () => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve(preferred);
+        });
+      });
+      server.on("error", (err: NodeJS.ErrnoException) => {
+        if (err.code === "EADDRINUSE") resolve(Studio.getAvailablePort(preferred + 1));
+        else reject(err);
+      });
+    });
+  }
+
   private static async waitForPort(port: number, maxAttempts = 50): Promise<void> {
     for (let i = 0; i < maxAttempts; i++) {
       const connected = await new Promise<boolean>((resolve) => {