Implement update checking, no UI for now

.github/workflows/nightly.yml

···
       - name: Build moonlight
         env:
           NODE_ENV: production
+          MOONLIGHT_BRANCH: nightly
+          MOONLIGHT_VERSION: ${{ github.sha }}
         run: pnpm run build
 
       - name: Write ref/commit to file

.github/workflows/release.yml

···
       - name: Build moonlight
         env:
           NODE_ENV: production
+          MOONLIGHT_BRANCH: stable
+          MOONLIGHT_VERSION: ${{ github.ref_name }}
         run: pnpm run build
       - name: Create archive
         run: |

build.mjs

···
 const browser = process.argv.includes("--browser");
 const mv2 = process.argv.includes("--mv2");
 
+const buildBranch = process.env.MOONLIGHT_BRANCH ?? "dev";
+const buildVersion = process.env.MOONLIGHT_VERSION ?? "dev";
+
 const external = [
   "electron",
   "fs",
···
 
   const define = {
     MOONLIGHT_ENV: `"${name}"`,
-    MOONLIGHT_PROD: prod.toString()
+    MOONLIGHT_PROD: prod.toString(),
+    MOONLIGHT_BRANCH: `"${buildBranch}"`,
+    MOONLIGHT_VERSION: `"${buildVersion}"`
   };
 
   for (const iterName of [

packages/browser/src/index.ts

···
     processedExtensions,
     nativesCache: {},
 
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH,
+
     getConfig,
     getConfigOption: <T>(ext: string, name: string) => {
       const config = getConfig(ext);
···
       return new Logger(id);
     },
 
+    getMoonlightDir() {
+      return "/";
+    },
     getExtensionDir: (ext: string) => {
       return `/extensions/${ext}`;
     },

packages/core-extensions/src/moonbase/node.ts

···
 
 const logger = moonlightNode.getLogger("moonbase");
 
+const updateTimerFile = path.join(
+  moonlightNode.getMoonlightDir(),
+  ".moonbase-update-timer"
+);
+const updateTimerInterval = 12 * 60 * 60 * 1000;
+
+const githubRepo = "moonlight-mod/moonlight";
+const nightlyRefUrl = "https://moonlight-mod.github.io/moonlight/ref";
+const userAgent = `moonlight/${moonlightNode.version} (https://github.com/moonlight-mod/moonlight)`;
+
+async function checkForMoonlightUpdate() {
+  const updateTimerStr = fs.existsSync(updateTimerFile)
+    ? fs.readFileSync(updateTimerFile, "utf-8")
+    : "0";
+  let updateTimer = parseInt(updateTimerStr);
+  if (isNaN(updateTimer)) updateTimer = 0;
+
+  const shouldCheck = Date.now() - updateTimer > updateTimerInterval;
+  if (!shouldCheck) return null;
+
+  fs.writeFileSync(updateTimerFile, Date.now().toString());
+
+  if (moonlightNode.branch === "stable") {
+    const req = await fetch(
+      `https://api.github.com/repos/${githubRepo}/releases/latest`,
+      {
+        headers: {
+          "User-Agent": userAgent
+        }
+      }
+    );
+    const json: { name: string } = await req.json();
+    return json.name !== moonlightNode.version ? json.name : null;
+  } else if (moonlightNode.branch === "nightly") {
+    const req = await fetch(nightlyRefUrl, {
+      headers: {
+        "User-Agent": userAgent
+      }
+    });
+    const ref = (await req.text()).split("\n")[0];
+    return ref !== moonlightNode.version ? ref : null;
+  }
+
+  return null;
+}
+
 async function fetchRepositories(repos: string[]) {
   const ret: Record<string, RepositoryManifest[]> = {};
 
   for (const repo of repos) {
     try {
-      const req = await fetch(repo);
+      const req = await fetch(repo, {
+        headers: {
+          "User-Agent": userAgent
+        }
+      });
       const json = await req.json();
       ret[repo] = json;
     } catch (e) {
···
   url: string,
   repo: string
 ) {
-  const req = await fetch(url);
+  const req = await fetch(url, {
+    headers: {
+      "User-Agent": userAgent
+    }
+  });
 
   const dir = moonlightNode.getExtensionDir(manifest.id);
   // remake it in case of updates
···
 }
 
 const exports: MoonbaseNatives = {
+  checkForMoonlightUpdate,
   fetchRepositories,
   installExtension,
   deleteExtension,

packages/core-extensions/src/moonbase/types.ts

···
 import { DetectedExtension, ExtensionManifest } from "types/src";
 
 export type MoonbaseNatives = {
+  checkForMoonlightUpdate(): Promise<string | null>;
   fetchRepositories(
     repos: string[]
   ): Promise<Record<string, RepositoryManifest[]>>;

packages/core-extensions/src/moonbase/webpackModules/stores.ts

···
 if (window._moonlightBrowserFS != null) {
   const browserFS = window._moonlightBrowserFS!;
   natives = {
+    checkForMoonlightUpdate: async () => {
+      // TODO
+      return null;
+    },
+
     fetchRepositories: async (repos) => {
       const ret: Record<string, RepositoryManifest[]> = {};
 

packages/injector/src/index.ts

···
         dependencyGraph: new Map()
       },
 
+      version: MOONLIGHT_VERSION,
+      branch: MOONLIGHT_BRANCH,
+
       getConfig,
       getConfigOption: <T>(ext: string, name: string) => {
         const config = getConfig(ext);

packages/node-preload/src/index.ts

···
 import { readConfig, writeConfig } from "@moonlight-mod/core/config";
 import { constants } from "@moonlight-mod/types";
 import { getExtensions } from "@moonlight-mod/core/extension";
-import { getExtensionsPath } from "@moonlight-mod/core/util/data";
+import {
+  getExtensionsPath,
+  getMoonlightDir
+} from "@moonlight-mod/core/util/data";
 import Logger, { initLogger } from "@moonlight-mod/core/util/logger";
 import {
   loadExtensions,
···
     extensions,
     processedExtensions,
     nativesCache: {},
+
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH,
+
     getConfig,
     getConfigOption: <T>(ext: string, name: string) => {
       const config = getConfig(ext);
···
       return new Logger(id);
     },
 
+    getMoonlightDir() {
+      return getMoonlightDir();
+    },
     getExtensionDir: (ext: string) => {
       const extPath = getExtensionsPath();
       return path.join(extPath, ext);

packages/types/src/globals.ts

···
   extensions: DetectedExtension[];
   processedExtensions: ProcessedExtensions;
 
+  version: string;
+  branch: string;
+
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
   getLogger: (id: string) => Logger;
···
   processedExtensions: ProcessedExtensions;
   nativesCache: Record<string, any>;
 
+  version: string;
+  branch: string;
+
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
   getNatives: (ext: string) => any | undefined;
   getLogger: (id: string) => Logger;
 
+  getMoonlightDir: () => string;
   getExtensionDir: (ext: string) => string;
   writeConfig: (config: Config) => void;
 };
···
     registerPatch: (patch: IdentifiedPatch) => void;
     registerWebpackModule: (module: IdentifiedWebpackModule) => void;
   };
+
+  version: string;
+  branch: string;
 
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;

packages/types/src/index.ts

···
   const MOONLIGHT_NODE_PRELOAD: boolean;
   const MOONLIGHT_WEB_PRELOAD: boolean;
   const MOONLIGHT_BROWSER: boolean;
+  const MOONLIGHT_BRANCH: string;
+  const MOONLIGHT_VERSION: string;
 
   var moonlightHost: MoonlightHost;
   var moonlightNode: MoonlightNode;

packages/web-preload/src/index.ts

···
       registerWebpackModule
     },
 
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH,
+
     getConfig: moonlightNode.getConfig.bind(moonlightNode),
     getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),
     getNatives: moonlightNode.getNatives.bind(moonlightNode),