@www.hyperlinks.space/program-kit 1.2.3

package/windows/forge/forge.config.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const requireCjs = createRequire(import.meta.url);
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// This file lives at app/windows/forge/ — app root is two levels up.
+const appDir = path.resolve(__dirname, "..", "..");
+const packageJson = JSON.parse(fs.readFileSync(path.join(appDir, "package.json"), "utf8"));
+const forgeProductName = packageJson.build?.productName ?? "Hyperlinks Space Program";
+
+const ICON_PATH = path.join(appDir, "assets", "icon.ico");
+// `@electron/packager` expects `main` relative to `packagerConfig.dir`.
+const MAIN_PROCESS_FILE_REL = path.join("windows", "build.cjs");
+
+function forgeLog(step, details = "") {
+  const ts = new Date().toISOString();
+  const suffix = details ? ` ${details}` : "";
+  console.log(`[forge:${ts}] ${step}${suffix}`);
+}
+
+// Forge config focused on Windows NSIS installer output.
+// Note: your current electron-builder setup includes heavy custom NSIS hook files;
+// Forge's stock NSIS maker may not replicate those exact installer pages out of the box.
+export default {
+  outDir: path.join(appDir, "releases", "forge", "artifacts"),
+  buildIdentifier: "hsp-forge",
+  hooks: {
+    generateAssets: async () => {
+      forgeLog("generateAssets");
+    },
+    prePackage: async (_forgeConfig, platform, arch) => {
+      forgeLog("prePackage", `platform=${platform} arch=${arch}`);
+      if (!fs.existsSync(ICON_PATH)) {
+        throw new Error(`[forge] packager icon missing: ${ICON_PATH}`);
+      }
+    },
+    packageAfterCopy: async (buildPath, electronVersion, platform, arch) => {
+      forgeLog(
+        "packageAfterCopy",
+        `platform=${platform} arch=${arch} electron=${electronVersion} buildPath=${buildPath}`,
+      );
+    },
+    packageAfterPrune: async (buildPath, electronVersion, platform, arch) => {
+      forgeLog(
+        "packageAfterPrune",
+        `platform=${platform} arch=${arch} electron=${electronVersion} buildPath=${buildPath}`,
+      );
+    },
+    packageAfterExtract: async (buildPath, electronVersion, platform, arch) => {
+      forgeLog(
+        "packageAfterExtract",
+        `platform=${platform} arch=${arch} electron=${electronVersion} buildPath=${buildPath}`,
+      );
+    },
+    postPackage: async (_forgeConfig, packageResult) => {
+      const outputs = Array.isArray(packageResult?.outputPaths)
+        ? packageResult.outputPaths.join(", ")
+        : "";
+      forgeLog(
+        "postPackage",
+        `platform=${packageResult?.platform} arch=${packageResult?.arch} outputs=${outputs}`,
+      );
+      if (packageResult?.platform === "win32" && Array.isArray(packageResult.outputPaths)) {
+        const { embedWindowsExeIcon } = requireCjs("../embed-windows-exe-icon.cjs");
+        for (const out of packageResult.outputPaths) {
+          await embedWindowsExeIcon({ appOutDir: out, projectDir: appDir });
+        }
+      }
+    },
+    preMake: async () => {
+      forgeLog("preMake");
+    },
+    postMake: async (_forgeConfig, makeResults) => {
+      const parts = Array.isArray(makeResults)
+        ? makeResults
+            .map((r) => `${r.platform}/${r.arch}:${(r.artifacts || []).length}`)
+            .join(", ")
+        : "";
+      forgeLog("postMake", `results=${parts}`);
+    },
+    // `@electron/packager` validates the Electron main entry using `package.json.main`
+    // from the directory being packaged. Your app uses Expo Router, so we temporarily
+    // switch main to the Electron main entry.
+    //
+    // This hook is only used inside Forge's packaging step.
+    readPackageJson: async (_forgeConfig, packageJSON) => {
+      packageJSON.main = MAIN_PROCESS_FILE_REL;
+      return packageJSON;
+    },
+  },
+  packagerConfig: {
+    dir: appDir,
+    name: forgeProductName,
+    appBundleId: "com.sraibaby.app",
+    icon: ICON_PATH,
+    // electron-packager reads this as the main process entry.
+    main: MAIN_PROCESS_FILE_REL,
+    // Improves exe identity in Properties / some SmartScreen heuristics (does not replace Authenticode signing).
+    // Do not set OriginalFilename here: electron-packager sets it to the real sanitized exe name
+    // (e.g. Hyperlinks-Space-Program.exe). Overriding with spaces breaks metadata vs on-disk name.
+    win32metadata: {
+      CompanyName: typeof packageJson.author === "string" ? packageJson.author : "sraibaby",
+      FileDescription: forgeProductName,
+      ProductName: forgeProductName,
+    },
+
+    // Match your electron-builder asar strategy.
+    asar: {
+      smartUnpack: true,
+    },
+    asarUnpack: ["**/*.node", "**/*.dll", "**/*.exe", "assets/icon.ico"],
+    // Plain file next to app.asar (Program Files\...\resources\icon.ico) — shell APIs cannot read paths inside app.asar.
+    extraResource: [ICON_PATH],
+  },
+  makers: [
+    {
+      name: "@felixrieseberg/electron-forge-maker-nsis",
+      platforms: ["win32"],
+      config: {
+        // Pass NSIS options through maker's electron-builder bridge.
+        // `runAfterFinish` at the top level is not part of this maker's documented schema.
+        getAdditionalConfig: () => ({
+          oneClick: false,
+          runAfterFinish: true,
+          perMachine: true,
+        }),
+      },
+    },
+    {
+      name: "@electron-forge/maker-zip",
+      platforms: ["win32"],
+      config: {},
+    },
+  ],
+};

package/windows/forge/make-with-stamp.cjs

@@ -0,0 +1,65 @@
+const { spawn } = require("child_process");
+const path = require("path");
+
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+
+function makeBuildStamp(d = new Date()) {
+  return `${pad2(d.getMonth() + 1)}${pad2(d.getDate())}${d.getFullYear()}_${pad2(d.getHours())}${pad2(d.getMinutes())}`;
+}
+
+function computeBuildStamp() {
+  if (process.env.BUILD_STAMP?.trim()) return process.env.BUILD_STAMP.trim();
+  const rid = process.env.RELEASE_BUILD_ID?.trim();
+  if (rid) {
+    const m = rid.match(/^build_(\d{8}_\d{4})_forge$/);
+    if (m) return m[1];
+  }
+  return makeBuildStamp();
+}
+
+function run() {
+  const appDir = path.resolve(__dirname, "..", "..");
+  const isVerbose = process.argv.includes("--verbose");
+  const cliPath = path.join(appDir, "node_modules", "@electron-forge", "cli", "dist", "electron-forge.js");
+
+  const BUILD_STAMP = computeBuildStamp();
+
+  const env = {
+    ...process.env,
+    BUILD_STAMP,
+  };
+
+  const args = [cliPath, "make", "--platform", "win32"];
+  if (isVerbose) args.push("--verbose");
+
+  console.log(`[forge] BUILD_STAMP=${env.BUILD_STAMP}`);
+  console.log(`[forge] node ${args.join(" ")}`);
+
+  const child = spawn(process.execPath, args, {
+    cwd: appDir,
+    env,
+    stdio: "inherit",
+    shell: false,
+  });
+
+  child.on("close", (code) => {
+    if (code !== 0) {
+      process.exit(code || 1);
+      return;
+    }
+    const cleanupPath = path.join(appDir, "windows", "forge-cleanup.cjs");
+    const c = spawn(process.execPath, [cleanupPath], {
+      cwd: appDir,
+      env: { ...process.env, BUILD_STAMP },
+      stdio: "inherit",
+      shell: false,
+    });
+    c.on("close", (c2) => process.exit(c2 || 0));
+    c.on("error", () => process.exit(1));
+  });
+  child.on("error", () => process.exit(1));
+}
+
+run();

package/windows/forge-cleanup.cjs

@@ -0,0 +1,255 @@
+/**
+ * After Electron Forge `make`, mirrors builder cleanup layout under
+ * `releases/forge/build_MMDDYYYY_HHMM_forge/` — installer only at root; zip, yml, unpacked, etc. in dev/.
+ * CI sets RELEASE_BUILD_ID=build_<date>_forge; locally the id defaults to the same pattern.
+ */
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { RELEASE_BUILD_DEV_DIRNAME } = require("./build-layout.cjs");
+const { productSlug } = require("./product-brand.cjs");
+
+const appDir = path.join(__dirname, "..");
+const releasesDir = path.join(appDir, "releases");
+const forgeArtifactsRoot = path.join(releasesDir, "forge", "artifacts");
+
+const pad = (n) => String(n).padStart(2, "0");
+const now = new Date();
+
+const defaultBuildNameFromClock =
+  "build_" +
+  pad(now.getMonth() + 1) +
+  pad(now.getDate()) +
+  now.getFullYear() +
+  "_" +
+  pad(now.getHours()) +
+  pad(now.getMinutes()) +
+  "_forge";
+
+const envBuildId = process.env.RELEASE_BUILD_ID?.trim();
+// Parent `make-with-stamp.cjs` passes BUILD_STAMP so folder name matches the installer stamp.
+const stampFromEnv = process.env.BUILD_STAMP?.trim();
+const buildName =
+  envBuildId && /^build_\d{8}_\d{4}_forge$/.test(envBuildId)
+    ? envBuildId
+    : stampFromEnv
+      ? `build_${stampFromEnv}_forge`
+      : defaultBuildNameFromClock;
+
+const buildDir = path.join(releasesDir, "forge", buildName);
+const devDir = path.join(buildDir, RELEASE_BUILD_DEV_DIRNAME);
+
+const latestYmlName = "latest.yml";
+const zipLatestYmlName = "zip-latest.yml";
+
+function walkDirs(dir, fn) {
+  if (!fs.existsSync(dir)) return;
+  const st = fs.statSync(dir);
+  if (!st.isDirectory()) return;
+  fn(dir);
+  for (const name of fs.readdirSync(dir)) {
+    walkDirs(path.join(dir, name), fn);
+  }
+}
+
+function collectFiles(root, predicate) {
+  const out = [];
+  function walk(d) {
+    if (!fs.existsSync(d)) return;
+    for (const name of fs.readdirSync(d)) {
+      const p = path.join(d, name);
+      const st = fs.statSync(p);
+      if (st.isDirectory()) walk(p);
+      else if (predicate(p, name)) out.push(p);
+    }
+  }
+  walk(root);
+  return out;
+}
+
+function pickInstallerExe() {
+  const exes = collectFiles(
+    forgeArtifactsRoot,
+    (p, name) =>
+      p.replace(/\\/g, "/").toLowerCase().includes("/make/") &&
+      name.toLowerCase().endsWith(".exe"),
+  );
+  if (exes.length === 0) return null;
+  for (const f of exes) {
+    const b = path.basename(f).toLowerCase();
+    if (b.includes("setup") || b.includes("installer")) return f;
+  }
+  return exes[0];
+}
+
+function pickZip() {
+  const zips = collectFiles(
+    forgeArtifactsRoot,
+    (p, name) =>
+      p.replace(/\\/g, "/").toLowerCase().includes("/make/") &&
+      name.toLowerCase().endsWith(".zip"),
+  );
+  if (zips.length === 0) return null;
+  return zips[0];
+}
+
+function pickYml(name) {
+  const ymls = collectFiles(
+    forgeArtifactsRoot,
+    (p, n) =>
+      p.replace(/\\/g, "/").toLowerCase().includes("/make/") &&
+      n.toLowerCase() === name,
+  );
+  return ymls[0] || null;
+}
+
+function findUnpackedDir() {
+  let found = null;
+  walkDirs(forgeArtifactsRoot, (d) => {
+    if (found) return;
+    const base = path.basename(d);
+    if (!base.endsWith("-win32-x64")) return;
+    const exeCandidates = fs.readdirSync(d).filter((n) => n.toLowerCase().endsWith(".exe"));
+    if (exeCandidates.length > 0) found = d;
+  });
+  return found;
+}
+
+function moveIfExists(src, dest) {
+  if (!fs.existsSync(src)) return false;
+  try {
+    fs.renameSync(src, dest);
+    console.log("Moved:", path.relative(appDir, dest));
+    return true;
+  } catch (e) {
+    try {
+      const stat = fs.statSync(src);
+      if (stat.isDirectory()) {
+        fs.cpSync(src, dest, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+      } else {
+        fs.copyFileSync(src, dest);
+        fs.unlinkSync(src);
+      }
+      console.log("Moved (copy+delete):", path.relative(appDir, dest));
+      return true;
+    } catch (e2) {
+      console.warn("Could not move", src, e2.message);
+      return false;
+    }
+  }
+}
+
+function stampFromBuildId(name) {
+  const m = name.match(/^build_(\d{8}_\d{4})_forge$/);
+  return m ? m[1] : null;
+}
+
+function writeLatestYmlForExe(exePath, ymlPath) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(appDir, "package.json"), "utf8"));
+  const version = String(pkg.version ?? "0.0.0");
+  const exeFileName = path.basename(exePath);
+  const buf = fs.readFileSync(exePath);
+  const sha512 = crypto.createHash("sha512").update(buf).digest("base64");
+  const size = buf.length;
+  const releaseDate = new Date().toISOString();
+  const yml =
+    `version: ${version}\n` +
+    `files:\n` +
+    `  - url: ${exeFileName}\n` +
+    `    sha512: ${sha512}\n` +
+    `    size: ${size}\n` +
+    `path: ${exeFileName}\n` +
+    `sha512: ${sha512}\n` +
+    `releaseDate: '${releaseDate}'\n`;
+  fs.writeFileSync(ymlPath, yml, "utf8");
+  console.log("Wrote:", path.relative(appDir, ymlPath));
+}
+
+function main() {
+  if (!fs.existsSync(forgeArtifactsRoot)) {
+    console.warn("No Forge output at releases/forge/artifacts/. Run forge make first.");
+    process.exit(1);
+  }
+
+  const stamp =
+    process.env.BUILD_STAMP?.trim() || stampFromBuildId(buildName);
+
+  if (!stamp) {
+    console.warn("Could not determine BUILD_STAMP (set env or use build_*_forge id).");
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(path.join(appDir, "package.json"), "utf8"));
+  const version = String(pkg.version ?? "0.0.0");
+  const targetExeName = `${productSlug}Installer_${stamp}.exe`;
+  const targetZipName = `${productSlug}_${version}.zip`;
+
+  const exeSrc = pickInstallerExe();
+  if (!exeSrc) {
+    console.warn("No installer .exe under releases/forge/artifacts/**/make/**");
+    process.exit(1);
+  }
+
+  fs.mkdirSync(devDir, { recursive: true });
+
+  const exeDest = path.join(buildDir, targetExeName);
+  moveIfExists(exeSrc, exeDest);
+
+  const latestSrc = pickYml(latestYmlName);
+  const latestDest = path.join(devDir, latestYmlName);
+  if (latestSrc) {
+    moveIfExists(latestSrc, latestDest);
+  }
+  if (fs.existsSync(exeDest) && !fs.existsSync(latestDest)) {
+    console.warn("No latest.yml from Forge — generating for electron-updater.");
+    writeLatestYmlForExe(exeDest, latestDest);
+  } else if (fs.existsSync(exeDest) && fs.existsSync(latestDest)) {
+    // ensure consistent
+  }
+
+  const zipSrc = pickZip();
+  if (!zipSrc) {
+    console.error(
+      "No portable .zip under releases/forge/artifacts/**/make/** — ensure @electron-forge/maker-zip is enabled.",
+    );
+    process.exit(1);
+  }
+  const zipDest = path.join(devDir, targetZipName);
+  moveIfExists(zipSrc, zipDest);
+
+  const zipLatestDest = path.join(devDir, zipLatestYmlName);
+  const zipLatestSrc = pickYml(zipLatestYmlName);
+  if (zipLatestSrc) {
+    moveIfExists(zipLatestSrc, zipLatestDest);
+  } else if (fs.existsSync(zipDest)) {
+    writeLatestYmlForExe(zipDest, zipLatestDest);
+  }
+
+  const unpacked = findUnpackedDir();
+  if (unpacked) {
+    const destUnpacked = path.join(devDir, "win-unpacked");
+    fs.mkdirSync(devDir, { recursive: true });
+    if (fs.existsSync(destUnpacked)) fs.rmSync(destUnpacked, { recursive: true, force: true });
+    fs.cpSync(unpacked, destUnpacked, { recursive: true });
+    console.log("Copied unpacked →", path.relative(appDir, destUnpacked));
+    fs.rmSync(unpacked, { recursive: true, force: true });
+  }
+
+  const blockmaps = collectFiles(forgeArtifactsRoot, (_, n) => n.toLowerCase().endsWith(".blockmap"));
+  for (const bm of blockmaps) {
+    moveIfExists(bm, path.join(devDir, path.basename(bm)));
+  }
+
+  try {
+    const forgeStaging = path.join(releasesDir, "forge", "artifacts");
+    if (fs.existsSync(forgeStaging)) {
+      fs.rmSync(forgeStaging, { recursive: true, force: true });
+      console.log("Removed releases/forge/artifacts/");
+    }
+  } catch (_) {}
+
+  console.log("Output:", path.join("releases", "forge", buildName));
+}
+
+main();

package/windows/hsp-app-process.ps1

@@ -0,0 +1,63 @@
+# Used by installer-hooks.nsi (nsExec::Exec, no console). Sync process names with package.json:
+# build.productName, name (npm), product-brand portable slug, legacy "Hyperlinks Space App".
+param(
+  [Parameter(Mandatory = $true)]
+  [ValidateSet("Kill", "Test")]
+  [string]$Action
+)
+$ErrorActionPreference = "SilentlyContinue"
+$InstDir = $env:HSP_INSTDIR
+if ([string]::IsNullOrWhiteSpace($InstDir)) {
+  if ($Action -eq "Test") { exit 1 }
+  exit 0
+}
+
+$names = @(
+  "Hyperlinks Space Program",
+  "Hyperlinks Space Program Helper",
+  "Hyperlinks Space Program Helper (GPU)",
+  "Hyperlinks Space Program Helper (Renderer)",
+  "Hyperlinks Space Program Helper (Plugin)",
+  "expo-template-default",
+  "HyperlinksSpaceProgram",
+  "Hyperlinks Space App"
+)
+
+function Get-Root([string]$p) {
+  if ([string]::IsNullOrWhiteSpace($p)) { return "" }
+  return $p.TrimEnd("\").ToLower()
+}
+$root = Get-Root $InstDir
+$rootContains = if ($root) { $root.ToLower() } else { "" }
+
+function Test-AnyRunning {
+  foreach ($n in $names) {
+    if (Get-Process -Name $n -ErrorAction SilentlyContinue) { return $true }
+  }
+  if (-not $root) { return $false }
+  $hit = Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object {
+    ($_.ExecutablePath -and $_.ExecutablePath.ToLower().StartsWith($root)) -or
+    ($_.CommandLine -and $rootContains -and $_.CommandLine.ToLower().Contains($rootContains))
+  } | Select-Object -First 1
+  return [bool]$hit
+}
+
+function Stop-All {
+  foreach ($n in $names) {
+    Get-Process -Name $n -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
+  }
+  if (-not $root) { return }
+  Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object {
+    ($_.ExecutablePath -and $_.ExecutablePath.ToLower().StartsWith($root)) -or
+    ($_.CommandLine -and $rootContains -and $_.CommandLine.ToLower().Contains($rootContains))
+  } | ForEach-Object {
+    Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue
+  }
+}
+
+if ($Action -eq "Test") {
+  if (Test-AnyRunning) { exit 0 } else { exit 1 }
+}
+Stop-All
+Start-Sleep -Milliseconds 2000
+exit 0