@mirinjs/cli 0.0.1-alpha.9 → 0.1.0-alpha.1

package/src/installer-win.ts

@@ -0,0 +1,166 @@
+/**
+ * Windows installer (NSIS) for `mirin release` — the Windows analogue of `dmg.ts`.
+ *
+ * Generates an NSIS script from the app folder + config and compiles it with
+ * `makensis` into a single `…-setup.exe`. The installer copies the app into
+ * Program Files (per-machine) or `%LOCALAPPDATA%\Programs` (per-user, the
+ * default — no elevation, and the in-app updater can swap the folder), creates
+ * Start Menu + Desktop shortcuts, writes an uninstaller, and registers an
+ * Add/Remove Programs entry. Customizable via {@link NsisConfig}.
+ *
+ * Requires `makensis` (NSIS 3+) on PATH; the caller checks `hasMakensis()` and
+ * falls back to the portable `.zip` when it's absent.
+ */
+
+import { $ } from "bun";
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+import type { NsisConfig } from "mirinjs";
+import { makeWindowsIcon } from "./icon-win.ts";
+
+export interface BuildNsisInput {
+  /** The assembled app folder (build/<App>). */
+  appDir: string;
+  appName: string;
+  /** Host exe name inside the folder (<App>.exe). */
+  exeName: string;
+  version: string;
+  /** Reverse-DNS app id → the Add/Remove Programs registry key. */
+  bundleId: string;
+  /** Output directory (build/release). */
+  outDir: string;
+  /** Output file name (e.g. stable-win32-x64-Anko-setup.exe). */
+  fileName: string;
+  options: NsisConfig;
+  /** Project root, for resolving a relative license / installerIcon. */
+  projectDir: string;
+}
+
+/** Whether `makensis` is on PATH. */
+export async function hasMakensis(): Promise<boolean> {
+  return (await $`makensis -VERSION`.quiet().nothrow()).exitCode === 0;
+}
+
+/** NSIS double-quoted string escaping (`"` and `$` are special). */
+function nsis(s: string): string {
+  return s.replace(/\$/g, "$$$$").replace(/"/g, '$\\"');
+}
+
+const resolve = (projectDir: string, p: string) => (isAbsolute(p) ? p : join(projectDir, p));
+
+/** Build the installer with `makensis`, returning the setup.exe path. */
+export async function buildNsisInstaller(input: BuildNsisInput): Promise<string> {
+  const { appDir, appName, exeName, version, bundleId, outDir, fileName, options, projectDir } = input;
+  const out = join(outDir, fileName);
+  rmSync(out, { force: true });
+
+  const perMachine = options.perMachine === true;
+  const assisted = options.oneClick !== true;
+  const desktop = options.desktopShortcut !== false;
+  const startMenu = options.startMenuShortcut !== false;
+  const runAfter = options.runAfterFinish !== false;
+  const changeDir = options.allowChangeInstallDir !== false;
+  const publisher = options.publisher ?? appName;
+  const root = perMachine ? "HKLM" : "HKCU";
+  const installDir =
+    options.installDir ?? (perMachine ? `$PROGRAMFILES64\\${appName}` : `$LOCALAPPDATA\\Programs\\${appName}`);
+
+  // Installer/uninstaller icon: an explicit .ico, else the app's bundled icon.ico.
+  let icon: string | undefined;
+  if (options.installerIcon) {
+    icon = makeWindowsIcon(resolve(projectDir, options.installerIcon), join(outDir, "_installer.ico"));
+  } else if (existsSync(join(appDir, "icon.ico"))) {
+    icon = join(appDir, "icon.ico");
+  }
+
+  const license = options.license ? resolve(projectDir, options.license) : undefined;
+  if (license && !existsSync(license)) throw new Error(`nsis: license not found: ${license}`);
+
+  const L: string[] = [];
+  L.push("Unicode True");
+  L.push("SetCompressor /SOLID lzma");
+  L.push('!include "MUI2.nsh"');
+  L.push('!include "FileFunc.nsh"');
+  L.push(`Name "${nsis(appName)}"`);
+  L.push(`OutFile "${nsis(out)}"`);
+  L.push(`InstallDir "${installDir}"`);
+  L.push(`RequestExecutionLevel ${perMachine ? "admin" : "user"}`);
+  L.push(`!define MUI_ABORTWARNING`);
+  if (icon) {
+    L.push(`!define MUI_ICON "${nsis(icon)}"`);
+    L.push(`!define MUI_UNICON "${nsis(icon)}"`);
+  }
+
+  // Pages. Assisted shows the full wizard; one-click is just the progress page.
+  if (assisted) L.push("!insertmacro MUI_PAGE_WELCOME");
+  if (license) L.push(`!insertmacro MUI_PAGE_LICENSE "${nsis(license)}"`);
+  if (assisted && changeDir) L.push("!insertmacro MUI_PAGE_DIRECTORY");
+  if (assisted && runAfter) {
+    L.push(`!define MUI_FINISHPAGE_RUN "$INSTDIR\\${nsis(exeName)}"`);
+  }
+  L.push("!insertmacro MUI_PAGE_INSTFILES");
+  if (assisted) L.push("!insertmacro MUI_PAGE_FINISH");
+  L.push("!insertmacro MUI_UNPAGE_CONFIRM");
+  L.push("!insertmacro MUI_UNPAGE_INSTFILES");
+  L.push('!insertmacro MUI_LANGUAGE "English"');
+
+  if (options.include) L.push("", "; --- user include ---", options.include, "");
+
+  const key = `Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\${bundleId}`;
+  const ctx = perMachine ? "all" : "current";
+
+  // Install section.
+  L.push("Section");
+  L.push(`  SetShellVarContext ${ctx}`);
+  L.push(`  SetOutPath "$INSTDIR"`);
+  L.push(`  File /r "${nsis(appDir)}\\*"`);
+  L.push(`  WriteUninstaller "$INSTDIR\\Uninstall.exe"`);
+  if (desktop) {
+    L.push(`  CreateShortcut "$DESKTOP\\${nsis(appName)}.lnk" "$INSTDIR\\${nsis(exeName)}"`);
+  }
+  if (startMenu) {
+    L.push(`  CreateDirectory "$SMPROGRAMS\\${nsis(appName)}"`);
+    L.push(
+      `  CreateShortcut "$SMPROGRAMS\\${nsis(appName)}\\${nsis(appName)}.lnk" "$INSTDIR\\${nsis(exeName)}"`,
+    );
+  }
+  // Estimated size for Add/Remove Programs.
+  L.push(`  \${GetSize} "$INSTDIR" "/S=0K" $0 $1 $2`);
+  L.push(`  IntFmt $0 "0x%08X" $0`);
+  const reg = (name: string, val: string) => L.push(`  WriteRegStr ${root} "${key}" "${name}" "${val}"`);
+  reg("DisplayName", nsis(appName));
+  reg("DisplayVersion", nsis(version));
+  reg("Publisher", nsis(publisher));
+  reg("DisplayIcon", `$INSTDIR\\${nsis(exeName)}`);
+  reg("InstallLocation", "$INSTDIR");
+  reg("UninstallString", '$INSTDIR\\Uninstall.exe');
+  reg("QuietUninstallString", '$INSTDIR\\Uninstall.exe /S');
+  L.push(`  WriteRegDWORD ${root} "${key}" "NoModify" 1`);
+  L.push(`  WriteRegDWORD ${root} "${key}" "NoRepair" 1`);
+  L.push(`  WriteRegDWORD ${root} "${key}" "EstimatedSize" $0`);
+  if (!assisted && runAfter) L.push(`  Exec '"$INSTDIR\\${nsis(exeName)}"'`);
+  L.push("SectionEnd");
+
+  // Uninstall section.
+  L.push("Section \"Uninstall\"");
+  L.push(`  SetShellVarContext ${ctx}`);
+  if (desktop) L.push(`  Delete "$DESKTOP\\${nsis(appName)}.lnk"`);
+  if (startMenu) {
+    L.push(`  Delete "$SMPROGRAMS\\${nsis(appName)}\\${nsis(appName)}.lnk"`);
+    L.push(`  RMDir "$SMPROGRAMS\\${nsis(appName)}"`);
+  }
+  L.push(`  RMDir /r "$INSTDIR"`);
+  L.push(`  DeleteRegKey ${root} "${key}"`);
+  L.push("SectionEnd");
+
+  const script = join(outDir, "_installer.nsi");
+  writeFileSync(script, L.join("\n") + "\n");
+  console.log(`[mirin release] compiling NSIS installer → ${fileName}`);
+  const res = await $`makensis -V2 ${script}`.nothrow();
+  rmSync(script, { force: true });
+  rmSync(join(outDir, "_installer.ico"), { force: true });
+  if (res.exitCode !== 0 || !existsSync(out)) {
+    throw new Error(`makensis failed (exit ${res.exitCode})`);
+  }
+  return out;
+}

package/src/release.ts

@@ -0,0 +1,192 @@
+/**
+ * `mirin release` — build the app and emit flat-named update artifacts.
+ *
+ * Produces, under `build/release/`:
+ *   {channel}-{platform}-{arch}-update.json          the manifest the app polls
+ *   {channel}-{platform}-{arch}-{Name}.app.tar.zst   the full bundle (fallback)
+ *   {channel}-{platform}-{arch}-{prevVersion}.patch  delta from the previous release
+ *
+ * The bundle is a zstd-compressed tar of the whole signed `.app`. Identity is the
+ * SHA-256 of the *uncompressed* tar (`tarHash`), so a delta patch can reconstruct
+ * it exactly. When the previous release is reachable at `baseUrl`, a bsdiff patch
+ * (prev → this) is generated; the app applies it instead of re-downloading the
+ * whole bundle, falling back to the full bundle whenever a patch isn't usable.
+ *
+ * Names are flat (no folders) so they upload as-is to GitHub Releases, S3/R2, or
+ * any static host. Channels coexist because the channel is part of every name.
+ */
+
+import { $ } from "bun";
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { build } from "./build.ts";
+import { buildDmg, notarizeAndStaple, type DmgOptions } from "./dmg.ts";
+import { buildNsisInstaller, hasMakensis } from "./installer-win.ts";
+import { loadCodec } from "mirinjs/codec";
+
+const sha256File = (path: string) =>
+  new Bun.CryptoHasher("sha256").update(readFileSync(path)).digest("hex");
+
+export async function release(projectDir = process.cwd()): Promise<number> {
+  const result = await build(projectDir);
+  if (!result.baseUrl) {
+    console.error("[mirin release] no `release.baseUrl` in mirin.config.ts — nothing to publish.");
+    return 1;
+  }
+
+  const isWindows = process.platform === "win32";
+  const platform = isWindows ? "win32" : "darwin";
+  const arch = process.arch; // "arm64" | "x64"
+  const prefix = `${result.channel}-${platform}-${arch}`;
+  const safeName = result.appName.replace(/[^A-Za-z0-9._-]/g, "");
+  const base = result.baseUrl.replace(/\/$/, "");
+  // The packaged unit: a flat app folder on Windows, an `.app` bundle on macOS.
+  const appArtifact = isWindows ? result.appName : `${result.appName}.app`;
+
+  const buildDir = join(projectDir, "build");
+  const outDir = join(buildDir, "release");
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  // Notarize + staple the .app (Developer ID, macOS) before packing, when
+  // credentials are present. The .tar.zst / patch updater bundles are made from
+  // this signed, stapled .app, so the updater swaps in an already-notarized app.
+  if (!isWindows) await notarizeAndStaple(result.app);
+
+  // Load the codec (zstd/bsdiff) from the *bundled* core, not the raw build output:
+  // on Windows mirin_core.dll imports libcef.dll. The DLL loader resolves imports
+  // from PATH (and the loader exe's dir), not the dll's own dir, so prepend the
+  // bundle dir to PATH so libcef.dll is found. (On macOS the framework loads at
+  // runtime, so result.coreDylib works directly.)
+  const codecCore = isWindows ? join(result.app, "mirin_core.dll") : result.coreDylib;
+  if (isWindows) process.env.PATH = `${result.app};${process.env.PATH ?? ""}`;
+  const codec = loadCodec(codecCore);
+
+  // Uncompressed tar — the identity + diff/patch basis (BSD tar keeps symlinks).
+  const newTar = join(outDir, "_new.tar");
+  await $`tar -cf ${newTar} -C ${buildDir} ${appArtifact}`;
+  const tarHash = sha256File(newTar);
+
+  // Full bundle: zstd(newTar).
+  const bundleName = `${prefix}-${safeName}${isWindows ? "" : ".app"}.tar.zst`;
+  const bundlePath = join(outDir, bundleName);
+  console.log(`[mirin release] compressing → ${bundleName}`);
+  codec.compress(newTar, bundlePath, 19);
+  const bundleSha = sha256File(bundlePath);
+  const bundleSize = readFileSync(bundlePath).byteLength;
+
+  // Delta patch vs the previous release (if reachable). Best-effort.
+  const patches: Array<{ fromVersion: string; url: string; sha256: string; size: number }> = [];
+  try {
+    const prevRes = await fetch(`${base}/${prefix}-update.json?t=${Date.now()}`, { redirect: "follow" });
+    if (prevRes.ok) {
+      const prev = (await prevRes.json()) as { version: string; bundle?: { url: string } };
+      if (prev.version && prev.version !== result.version && prev.bundle?.url) {
+        console.log(`[mirin release] generating delta ${prev.version} → ${result.version}…`);
+        const tmp = join(tmpdir(), `mirin-release-${Date.now()}`);
+        mkdirSync(tmp, { recursive: true });
+        const prevZst = join(tmp, "prev.tar.zst");
+        const dl = await fetch(`${base}/${prev.bundle.url}`, { redirect: "follow" });
+        if (!dl.ok || !dl.body) throw new Error(`prev bundle ${dl.status}`);
+        await Bun.write(prevZst, await dl.arrayBuffer());
+        const prevTar = join(tmp, "prev.tar");
+        codec.decompress(prevZst, prevTar);
+        const rawPatch = join(tmp, "patch.bin");
+        codec.diff(prevTar, newTar, rawPatch); // bsdiff
+        const patchName = `${prefix}-${prev.version}.patch`;
+        const patchPath = join(outDir, patchName);
+        codec.compress(rawPatch, patchPath, 19);
+        rmSync(tmp, { recursive: true, force: true });
+        patches.push({
+          fromVersion: prev.version,
+          url: patchName,
+          sha256: sha256File(patchPath),
+          size: readFileSync(patchPath).byteLength,
+        });
+      }
+    }
+  } catch (e) {
+    console.warn(`[mirin release] skipping delta patch: ${e instanceof Error ? e.message : e}`);
+  }
+
+  rmSync(newTar, { force: true });
+
+  const manifest = {
+    version: result.version,
+    channel: result.channel,
+    platform,
+    arch,
+    tarHash,
+    bundle: { url: bundleName, sha256: bundleSha, size: bundleSize },
+    patches,
+  };
+  const manifestName = `${prefix}-update.json`;
+  await Bun.write(join(outDir, manifestName), `${JSON.stringify(manifest, null, 2)}\n`);
+
+  // Distributable installer for first-time installs (the updater uses the
+  // .tar.zst/patch): a drag-to-Applications .dmg on macOS, a .zip of the app
+  // folder on Windows.
+  let installerName: string | undefined;
+  let installerSize = 0;
+  if (isWindows) {
+    // Preferred: a real NSIS installer (Program Files / per-user install, Start
+    // Menu + Desktop shortcuts, uninstaller, Add/Remove Programs). Falls back to a
+    // portable .zip when nsis is disabled or makensis isn't installed.
+    const wantsInstaller = result.nsis !== false;
+    if (wantsInstaller && (await hasMakensis())) {
+      installerName = `${prefix}-${safeName}-setup.exe`;
+      const exePath = await buildNsisInstaller({
+        appDir: result.app,
+        appName: result.appName,
+        exeName: `${result.appName}.exe`,
+        version: result.version,
+        bundleId: result.bundleId,
+        outDir,
+        fileName: installerName,
+        options: typeof result.nsis === "object" ? result.nsis : {},
+        projectDir: result.projectDir,
+      });
+      installerSize = readFileSync(exePath).byteLength;
+    } else {
+      if (wantsInstaller) {
+        console.warn(
+          "[mirin release] makensis (NSIS) not found — shipping the portable .zip. " +
+            "Install NSIS (e.g. `scoop install nsis`) for an installer.",
+        );
+      }
+      installerName = `${prefix}-${safeName}.zip`;
+      console.log(`[mirin release] zipping → ${installerName}`);
+      const zipPath = join(outDir, installerName);
+      rmSync(zipPath, { force: true });
+      // bsdtar (Windows `tar`) creates a .zip from the extension with `-a`.
+      await $`tar -a -cf ${zipPath} -C ${buildDir} ${appArtifact}`;
+      installerSize = readFileSync(zipPath).byteLength;
+    }
+  } else if (result.dmg !== false) {
+    installerName = `${prefix}-${safeName}.dmg`;
+    console.log(`[mirin release] building installer → ${installerName}`);
+    const options: DmgOptions = typeof result.dmg === "object" ? result.dmg : {};
+    const dmgPath = await buildDmg({
+      app: result.app,
+      appName: result.appName,
+      outDir,
+      fileName: installerName,
+      options,
+      projectDir: result.projectDir,
+      signIdentity: result.signIdentity,
+    });
+    await notarizeAndStaple(dmgPath); // no-op without notary credentials
+    installerSize = readFileSync(dmgPath).byteLength;
+  }
+
+  const mb = (n: number) => (n / 1e6).toFixed(1);
+  console.log(`\n[mirin release] done → build/release/`);
+  console.log(`  ${manifestName}`);
+  console.log(`  ${bundleName} (${mb(bundleSize)} MB)`);
+  for (const p of patches) console.log(`  ${p.url} (${mb(p.size)} MB delta from ${p.fromVersion})`);
+  if (installerName) console.log(`  ${installerName} (${mb(installerSize)} MB installer)`);
+  console.log(`\nUpload all of build/release/ to: ${result.baseUrl}`);
+  if (existsSync(join(outDir, "_new.tar"))) rmSync(join(outDir, "_new.tar"), { force: true });
+  return 0;
+}

package/src/temps.ts

@@ -0,0 +1,24 @@
+/**
+ * Remove `bun build --compile` scratch files (`.*.bun-build`) from a directory.
+ *
+ * `bun build --compile` writes these temp files into the working directory and
+ * normally cleans them up — but a hard-killed build leaves them behind, where
+ * they accumulate in the project root. The dev/build commands sweep them first.
+ */
+
+import { readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+export function sweepBuildTemps(dir: string): void {
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name.endsWith(".bun-build")) {
+      rmSync(join(dir, name), { force: true });
+    }
+  }
+}