@vnejs/desktop 0.0.35 → 0.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/desktop",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "Tools to run desktop app of @vnejs",
   "main": "src/index.js",
   "bin": {
@@ -15,13 +15,15 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "commander": "14.0.3",
-    "express": "4.21.2",
-    "get-port": "7.1.0",
-    "open": "8.2.1"
+    "@fastify/cors": "~11.2.0",
+    "@fastify/static": "~9.1.3",
+    "commander": "~15.0.0",
+    "fastify": "~5.8.5",
+    "get-port": "~7.2.0",
+    "open": "~11.0.0"
   },
   "devDependencies": {
-    "@electron/packager": "19.0.5",
-    "electron": "~40.8.0"
+    "@electron/packager": "~20.0.1",
+    "electron": "~42.3.3"
   }
 }

package/src/electron.js

@@ -1,11 +1,21 @@
-const { app, BrowserWindow } = require("electron");
+const { app, protocol, BrowserWindow, net } = require("electron");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+
 let mainWindow;
 
+protocol.registerSchemesAsPrivileged([{ scheme: "vnejs", privileges: { standard: true, secure: true, supportFetchAPI: true, corsEnabled: true } }]);
+
 const createWindow = (options) => {
-  mainWindow = new BrowserWindow({ autoHideMenuBar: options.isProd, fullscreen: true, frame: true });
+  mainWindow = new BrowserWindow({
+    autoHideMenuBar: options.isProd,
+    fullscreen: true,
+    frame: true,
+    webPreferences: { contextIsolation: true, nodeIntegration: false },
+  });
 
   if (options.port) mainWindow.loadURL(`http://localhost:${options.port}/`);
-  if (options.file) mainWindow.loadFile(options.file, { search: options.search });
+  if (options.file) mainWindow.loadURL(`vnejs://${options.file}`);
 
   mainWindow.on("closed", () => (mainWindow = null));
   options.isProd ? mainWindow.removeMenu() : mainWindow.webContents.openDevTools();
@@ -17,7 +27,20 @@ const createWindow = (options) => {
 };
 
 const runElectron = (options) => {
-  app.whenReady().then(() => createWindow(options));
+  app.whenReady().then(() => {
+    protocol.handle("vnejs", (request) => {
+      const url = new URL(request.url);
+
+      let pathname = decodeURIComponent(url.pathname);
+
+      if (pathname === "/") pathname = "/index.html";
+
+      const filePath = path.join(options.rootDir, "dist", pathname);
+
+      return net.fetch(pathToFileURL(filePath).toString());
+    });
+    createWindow(options);
+  });
   app.on("window-all-closed", () => process.platform !== "darwin" && app.quit());
   app.on("activate", () => mainWindow === null && createWindow(options));
 };

package/src/server.js

@@ -1,83 +1,198 @@
 const path = require("path");
-const express = require("express");
+const os = require("os");
+const fastify = require("fastify");
 const getPort = require("get-port").default;
-const bodyParser = require("body-parser");
-const { writeFile, appendFile, readdirSync, existsSync, readFile } = require("fs");
+const fastifyCors = require("@fastify/cors");
+const fastifyStatic = require("@fastify/static");
+const { readFile, readdir, writeFile, appendFile, mkdir, unlink, access } = require("fs/promises");
 
-const runServer = async ({ rootDir, oldApp, achievementLock, achievementUnlock } = {}) => {
+const getPrefix = (key) => {
+  const dot = key.indexOf(".");
+
+  return dot === -1 ? key : key.slice(0, dot);
+};
+
+const splitStateByPrefix = (state) =>
+  Object.entries(state).reduce((groups, [key, value]) => {
+    const prefix = getPrefix(key);
+
+    groups[prefix] ??= {};
+    groups[prefix][key] = value;
+
+    return groups;
+  }, {});
+
+const isIPv4 = (family) => family === "IPv4" || family === 4;
+
+const getServerUrls = (port) => {
+  const local = [`http://localhost:${port}/`, `http://127.0.0.1:${port}/`];
+  const network = new Set();
+
+  for (const interfaces of Object.values(os.networkInterfaces())) {
+    for (const iface of interfaces) {
+      if (isIPv4(iface.family) && !iface.internal) network.add(`http://${iface.address}:${port}/`);
+    }
+  }
+
+  return { local, network: [...network] };
+};
+
+const logServerAddresses = (port) => {
+  const { local, network } = getServerUrls(port);
+
+  console.log("server started:");
+  console.log("  locally:");
+  local.forEach((url) => console.log(`    ${url}`));
+
+  if (network.length) {
+    console.log("  on local network (wifi):");
+    network.forEach((url) => console.log(`    ${url}`));
+  } else {
+    console.log("  on local network (wifi): not available");
+  }
+};
+
+const pathExists = async (target) => {
+  try {
+    await access(target);
+
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const runServer = async ({ rootDir, stateDir, oldApp, achievementLock, achievementUnlock } = {}) => {
   const port = await getPort();
 
-  const stateJson = path.join(rootDir, "state.json");
+  const resolvedStateDir = stateDir || path.join(rootDir, "state");
   const gamePath = path.join(rootDir, "game");
 
-  const onSaveState = (req, res) => writeFile(stateJson, JSON.stringify(req.body), (err) => (err ? res.json({ status: "error" }) : res.json({ status: "ok" })));
+  const ensureStateDir = () => mkdir(resolvedStateDir, { recursive: true });
+
+  const getStateFiles = async () => {
+    try {
+      const files = await readdir(resolvedStateDir);
+
+      return files.filter((file) => file.endsWith(".json"));
+    } catch {
+      return [];
+    }
+  };
+
+  const onSaveState = async (req, reply) => {
+    try {
+      await ensureStateDir();
+
+      const groups = splitStateByPrefix(req.body);
+      const activePrefixes = new Set(Object.keys(groups));
+      const stalePrefixes = (await getStateFiles()).map((file) => file.slice(0, -".json".length)).filter((prefix) => !activePrefixes.has(prefix));
+
+      await Promise.all([
+        ...Object.entries(groups).map(([prefix, state]) => writeFile(path.join(resolvedStateDir, `${prefix}.json`), JSON.stringify(state))),
+        ...stalePrefixes.map((prefix) => unlink(path.join(resolvedStateDir, `${prefix}.json`))),
+      ]);
+
+      return reply.send({ status: "ok" });
+    } catch {
+      return reply.send({ status: "error" });
+    }
+  };
+
+  const onGetState = async (req, reply) => {
+    const stateFiles = await getStateFiles();
 
-  const onGetState = (req, res) =>
-    readFile(stateJson, (err, data) =>
-      err ? writeFile(stateJson, "{}", () => res.json({ status: "ok", state: {} })) : res.json({ status: "ok", state: JSON.parse(data.toString()) }),
-    );
+    if (!stateFiles.length) return reply.send({ status: "ok", state: {} });
 
-  const onAchievementLock = (req, res) => {
+    try {
+      const chunks = await Promise.all(stateFiles.map((file) => readFile(path.join(resolvedStateDir, file), "utf8").then(JSON.parse)));
+
+      return reply.send({ status: "ok", state: Object.assign({}, ...chunks) });
+    } catch {
+      return reply.send({ status: "error" });
+    }
+  };
+
+  const onAchievementLock = (req, reply) => {
     typeof achievementLock === "function" && achievementLock(req.body?.id, req.body?.data);
 
-    return res.json({ status: "ok" });
+    return reply.send({ status: "ok" });
   };
-  const onAchievementUnlock = (req, res) => {
+
+  const onAchievementUnlock = (req, reply) => {
     typeof achievementUnlock === "function" && achievementUnlock(req.body?.id, req.body?.data);
 
-    return res.json({ status: "ok" });
+    return reply.send({ status: "ok" });
   };
 
-  const onLog = (req, res) => {
-    res.end("ok");
+  const onLog = (req, reply) => {
+    reply.send("ok");
 
     appendFile(path.join(rootDir, "log.txt"), `${req.body.log}\n`);
   };
 
-  console.log("server will try to start on localhost: ", port);
+  const createApp = async () => {
+    const app = fastify({ bodyLimit: 50 * 1024 * 1024 });
 
-  const app =
-    oldApp ||
-    express()
-      .use((req, res, next) => {
-        res.header("Access-Control-Allow-Origin", "*");
+    await app.register(fastifyCors, {
+      origin: "*",
+      methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+      allowedHeaders: ["Content-Type", "Authorization"],
+    });
 
-        next();
-      })
-      .use(bodyParser.json({ limit: "50mb" }))
-      .use(express.static(path.join(rootDir, "dist")))
-      .use("/state/save", onSaveState)
-      .use("/state/get", onGetState)
-      .use("/achievement/lock", onAchievementLock)
-      .use("/achievement/unlock", onAchievementUnlock)
-      .use("/log", onLog);
+    app.post("/state/save", onSaveState);
+    app.get("/state/get", onGetState);
+    app.post("/achievement/lock", onAchievementLock);
+    app.post("/achievement/unlock", onAchievementUnlock);
+    app.post("/log", onLog);
 
-  readdirSync(gamePath).forEach((modDir) => {
-    const mediaDir = path.join(gamePath, modDir, "media");
-    const publicDir = path.join(gamePath, modDir, "public");
+    const publicDirs = [path.join(rootDir, "dist")];
+    const mediaDirs = [];
 
-    existsSync(mediaDir) && app.use("/media", express.static(mediaDir));
-    existsSync(publicDir) && app.use(express.static(publicDir));
-  });
+    let modDirs = [];
 
-  return new Promise(async (resolve) => {
-    const server = app.listen(port);
+    try {
+      modDirs = await readdir(gamePath);
+    } catch {}
 
-    server.on("listening", () => {
-      console.log("server started on port: ", port);
+    for (const modDir of modDirs) {
+      const mediaDir = path.join(gamePath, modDir, "media");
+      const publicDir = path.join(gamePath, modDir, "public");
 
-      resolve(port);
-    });
-    server.on("error", async (error) => {
-      if (error.code === "EADDRINUSE") {
-        console.log("server not started on port: ", port);
+      if (await pathExists(mediaDir)) mediaDirs.push(mediaDir);
+      if (await pathExists(publicDir)) publicDirs.push(publicDir);
+    }
 
-        await runServer({ rootDir, oldApp: app, achievementLock, achievementUnlock });
+    await app.register(fastifyStatic, { root: publicDirs });
 
-        resolve(port);
-      }
-    });
-  });
+    if (mediaDirs.length) {
+      await app.register(fastifyStatic, {
+        root: mediaDirs,
+        prefix: "/media/",
+        decorateReply: false,
+      });
+    }
+
+    return app;
+  };
+
+  const app = oldApp || (await createApp());
+
+  try {
+    await app.listen({ port, host: "0.0.0.0" });
+
+    logServerAddresses(port);
+
+    return port;
+  } catch (error) {
+    if (error.code === "EADDRINUSE") {
+      console.log("server not started on port: ", port);
+
+      return runServer({ rootDir, stateDir, oldApp: app, achievementLock, achievementUnlock });
+    }
+
+    throw error;
+  }
 };
 
 module.exports = { runServer };

package/src/web.js

@@ -1,6 +1,10 @@
-const open = require("open");
+const open = require("open").default;
 const { runServer } = require("./server");
 
 const getRootDir = () => process.env.PWD || process.env.INIT_CWD;
 
-module.exports = () => runServer({ rootDir: getRootDir() }).then((port) => open(`http://localhost:${port}`));
+module.exports = async () => {
+  const port = await runServer({ rootDir: getRootDir() });
+
+  return open(`http://localhost:${port}`);
+};