@mirinjs/cli 0.0.1-alpha.1 → 0.0.1-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirinjs/cli",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.11",
   "description": "CLI for mirin apps: dev, build, init.",
   "type": "module",
   "license": "MIT",
@@ -27,10 +27,10 @@
     "bun": ">=1.2.0"
   },
   "dependencies": {
-    "create-mirinjs": "0.0.1-alpha.0"
+    "create-mirinjs": "0.0.1-alpha.11"
   },
   "optionalDependencies": {
-    "@mirinjs/darwin-arm64": "0.0.1-alpha.0"
+    "@mirinjs/darwin-arm64": "0.0.1-alpha.11"
   },
   "publishConfig": {
     "access": "public"

package/src/artifacts.ts

@@ -118,13 +118,17 @@ async function ensureCef(): Promise<string> {
   const url = `https://github.com/${REPO_SLUG}/releases/download/v${version}/${asset}`;
   console.log(`[mirin] downloading CEF for ${platformTag()} (one-time, ~hundreds of MB)…`);
 
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`mirin: failed to download CEF from ${url} (HTTP ${res.status}).`);
-  }
+  // Download with curl, not `Bun.write(file, await fetch(url))`: the latter
+  // pins a core at 100% CPU and never completes on large gzip responses
+  // (the streaming write path). curl is fast and ubiquitous.
   const archive = join(tmpdir(), asset);
-  await Bun.write(archive, res);
-  await $`tar -xzf ${archive} -C ${cacheDir}`;
+  try {
+    await $`curl -fSL --retry 3 -o ${archive} ${url}`;
+    await $`tar -xzf ${archive} -C ${cacheDir}`;
+  } catch (err) {
+    rmSync(archive, { force: true });
+    throw new Error(`mirin: failed to download CEF from ${url} (${err}).`);
+  }
   rmSync(archive, { force: true });
   return cacheDir;
 }

package/src/build.ts

@@ -16,23 +16,52 @@
  */
 
 import { $ } from "bun";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { buildAppBundle } from "./bundle.ts";
 import { resolveArtifacts } from "./artifacts.ts";
+import { sweepBuildTemps } from "./temps.ts";
 
-export async function build(projectDir = process.cwd()): Promise<number> {
+export interface BuildResult {
+  /** Path to the assembled .app. */
+  app: string;
+  appName: string;
+  bundleId: string;
+  /** App version (from the project's package.json). */
+  version: string;
+  /** Update channel (config.release.channel ?? "stable"). */
+  channel: string;
+  /** Update baseUrl, if `release` is configured. */
+  baseUrl?: string;
+}
+
+/** Read the project's package.json version (the single source of app version). */
+function appVersion(projectDir: string): string {
+  const pkgPath = join(projectDir, "package.json");
+  if (!existsSync(pkgPath)) return "0.0.0";
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+export async function build(projectDir = process.cwd()): Promise<BuildResult> {
   const outDir = join(projectDir, "build");
   const work = join(projectDir, ".mirin");
   mkdirSync(outDir, { recursive: true });
   mkdirSync(work, { recursive: true });
+  sweepBuildTemps(projectDir);
 
   const config = (await import(join(projectDir, "mirin.config.ts"))).default;
   const appName: string = config.name ?? "Mirin App";
   const bundleId: string = config.id ?? "dev.mirin.app";
   const mainEntry = join(projectDir, config.main ?? "main/main.ts");
+  const version = appVersion(projectDir);
+  const channel: string = config.release?.channel ?? "stable";
+  const baseUrl: string | undefined = config.release?.baseUrl;
 
-  console.log(`[mirin build] ${appName}`);
+  console.log(`[mirin build] ${appName} ${version}`);
 
   // 1. production UI
   console.log("[mirin build] vite build…");
@@ -51,6 +80,11 @@ export async function build(projectDir = process.cwd()): Promise<number> {
   // 5. assemble + sign
   console.log("[mirin build] assembling .app…");
   rmSync(join(outDir, `${appName}.app`), { recursive: true, force: true });
+  // version.json embeds the running app's update identity (read by app.updater).
+  // Only when `release` is configured — otherwise the app has no updater.
+  const versionJson = baseUrl
+    ? JSON.stringify({ version, channel, baseUrl, name: appName, identifier: bundleId })
+    : undefined;
   const { app } = await buildAppBundle({
     appName,
     bundleId,
@@ -59,15 +93,18 @@ export async function build(projectDir = process.cwd()): Promise<number> {
     coreDylib: artifacts.coreDylib,
     helperBin: artifacts.helperBin,
     cefPath: artifacts.cefPath,
+    version,
+    icon: config.icon ? join(projectDir, config.icon) : undefined,
     signIdentity: process.env.MIRIN_SIGN_IDENTITY,
     resources: {
       uiDir: join(projectDir, "dist"),
       workerJs,
       manifestJson: JSON.stringify({ windows: config.windows }),
+      versionJson,
     },
   });
 
   console.log(`\n[mirin build] done → ${app}`);
   console.log(`  open "${app}"`);
-  return 0;
+  return { app, appName, bundleId, version, channel, baseUrl };
 }

package/src/bundle.ts

@@ -33,6 +33,10 @@ export interface BundleOptions {
   coreDylib: string; // libmirin_core.dylib
   helperBin: string; // compiled mirin-helper binary
   cefPath: string; // dir containing the CEF framework (vendor/cef)
+  /** App version → Info.plist CFBundleShortVersionString/CFBundleVersion. */
+  version?: string;
+  /** App icon source: a .icns, a .iconset dir, or a square .png. Optional. */
+  icon?: string;
   /** Codesign identity; "-" (default) is ad-hoc. Set to a Developer ID to ship. */
   signIdentity?: string;
   /** Production-only resources placed under Contents/Resources. */
@@ -40,9 +44,54 @@ export interface BundleOptions {
     uiDir?: string; // Vite dist/, copied to Resources/ui (served via app://ui)
     workerJs?: string; // bundled main-process Worker entry -> Resources/worker.js
     manifestJson?: string; // serialized manifest -> Resources/mirin.manifest.json
+    versionJson?: string; // serialized version.json -> Resources/version.json (updater)
   };
 }
 
+/** The 10 standard iconset renditions (point size + @1x/@2x pixel size). */
+const ICONSET_RENDITIONS = [
+  { name: "icon_16x16.png", px: 16 },
+  { name: "icon_16x16@2x.png", px: 32 },
+  { name: "icon_32x32.png", px: 32 },
+  { name: "icon_32x32@2x.png", px: 64 },
+  { name: "icon_128x128.png", px: 128 },
+  { name: "icon_128x128@2x.png", px: 256 },
+  { name: "icon_256x256.png", px: 256 },
+  { name: "icon_256x256@2x.png", px: 512 },
+  { name: "icon_512x512.png", px: 512 },
+  { name: "icon_512x512@2x.png", px: 1024 },
+];
+
+/**
+ * Render the app icon to `Resources/icon.icns` and return the CFBundleIconFile
+ * stem ("icon"), or undefined if there's no usable source. Accepts a `.icns`
+ * (copied), a `.iconset` directory (iconutil), or a square `.png` (rendered to
+ * a full iconset via sips, then iconutil).
+ */
+async function writeIcon(iconSrc: string, resources: string): Promise<string | undefined> {
+  if (!existsSync(iconSrc)) {
+    console.warn(`[mirin] icon not found, skipping: ${iconSrc}`);
+    return undefined;
+  }
+  const icns = join(resources, "icon.icns");
+
+  if (iconSrc.endsWith(".icns")) {
+    cpSync(iconSrc, icns);
+  } else if (iconSrc.endsWith(".iconset")) {
+    await $`iconutil -c icns ${iconSrc} -o ${icns}`.quiet();
+  } else {
+    const iconset = join(resources, "icon.iconset");
+    rmSync(iconset, { recursive: true, force: true });
+    mkdirSync(iconset, { recursive: true });
+    for (const { name, px } of ICONSET_RENDITIONS) {
+      await $`sips -z ${px} ${px} ${iconSrc} --out ${join(iconset, name)}`.quiet();
+    }
+    await $`iconutil -c icns ${iconset} -o ${icns}`.quiet();
+    rmSync(iconset, { recursive: true, force: true });
+  }
+  return "icon";
+}
+
 type PlistValue = string | boolean | Record<string, string>;
 
 function plist(entries: Record<string, PlistValue>): string {
@@ -87,25 +136,30 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
   cpSync(opts.hostExe, join(macos, appName));
   cpSync(opts.coreDylib, join(macos, "libmirin_core.dylib"));
 
-  writeFileSync(
-    join(contents, "Info.plist"),
-    plist({
-      CFBundleDevelopmentRegion: "en",
-      CFBundleDisplayName: appName,
-      CFBundleExecutable: appName,
-      CFBundleIdentifier: bundleId,
-      CFBundleInfoDictionaryVersion: "6.0",
-      CFBundleName: appName,
-      CFBundlePackageType: "APPL",
-      CFBundleShortVersionString: "0.0.1",
-      CFBundleVersion: "0.0.1",
-      LSMinimumSystemVersion: "13.0",
-      NSHighResolutionCapable: true,
-      NSSupportsAutomaticGraphicsSwitching: true,
-      LSFileQuarantineEnabled: true,
-      LSEnvironment: { MallocNanoZone: "0" },
-    }),
-  );
+  // Render the icon (if any) into Resources before writing the plist, so we
+  // only set CFBundleIconFile when an icon was actually produced.
+  const iconFile = opts.icon ? await writeIcon(opts.icon, join(contents, "Resources")) : undefined;
+  const version = opts.version ?? "0.0.1";
+
+  const info: Record<string, PlistValue> = {
+    CFBundleDevelopmentRegion: "en",
+    CFBundleDisplayName: appName,
+    CFBundleExecutable: appName,
+    CFBundleIdentifier: bundleId,
+    CFBundleInfoDictionaryVersion: "6.0",
+    CFBundleName: appName,
+    CFBundlePackageType: "APPL",
+    CFBundleShortVersionString: version,
+    CFBundleVersion: version,
+    LSMinimumSystemVersion: "13.0",
+    NSHighResolutionCapable: true,
+    NSSupportsAutomaticGraphicsSwitching: true,
+    LSFileQuarantineEnabled: true,
+    LSEnvironment: { MallocNanoZone: "0" },
+  };
+  if (iconFile) info.CFBundleIconFile = iconFile;
+
+  writeFileSync(join(contents, "Info.plist"), plist(info));
 
   cpSync(join(cefPath, FRAMEWORK), join(frameworks, FRAMEWORK), {
     recursive: true,
@@ -123,6 +177,11 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
   if (opts.resources?.manifestJson != null) {
     writeFileSync(join(resources, "mirin.manifest.json"), opts.resources.manifestJson);
   }
+  // version.json is the running app's self-knowledge for the updater. Written
+  // before the codesign loop below so the signature covers it.
+  if (opts.resources?.versionJson != null) {
+    writeFileSync(join(resources, "version.json"), opts.resources.versionJson);
+  }
 
   for (const { suffix, id } of HELPER_TYPES) {
     const name = `${appName} Helper${suffix}`;
@@ -139,8 +198,8 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
         CFBundleInfoDictionaryVersion: "6.0",
         CFBundleName: name,
         CFBundlePackageType: "APPL",
-        CFBundleShortVersionString: "0.0.1",
-        CFBundleVersion: "0.0.1",
+        CFBundleShortVersionString: version,
+        CFBundleVersion: version,
         LSMinimumSystemVersion: "13.0",
         LSUIElement: "1",
         NSHighResolutionCapable: true,

package/src/dev.ts

@@ -13,12 +13,16 @@ import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { buildAppBundle } from "./bundle.ts";
 import { resolveArtifacts } from "./artifacts.ts";
+import { sweepBuildTemps } from "./temps.ts";
 
 const DEV_URL = "http://localhost:5173";
 
 export async function dev(projectDir = process.cwd()): Promise<number> {
   const work = join(projectDir, ".mirin");
   mkdirSync(work, { recursive: true });
+  // `bun build --compile` drops temp *.bun-build files in the cwd; clear any left
+  // behind by a previously interrupted run so they don't pile up in the project.
+  sweepBuildTemps(projectDir);
 
   // --- load the manifest ---
   const config = (await import(join(projectDir, "mirin.config.ts"))).default;
@@ -46,6 +50,7 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
     coreDylib: artifacts.coreDylib,
     helperBin: artifacts.helperBin,
     cefPath: artifacts.cefPath,
+    icon: config.icon ? join(projectDir, config.icon) : undefined,
   });
 
   // --- start Vite ---

package/src/index.ts

@@ -6,6 +6,7 @@
 import { resolve } from "node:path";
 import { dev } from "./dev.ts";
 import { build } from "./build.ts";
+import { release } from "./release.ts";
 import { scaffold } from "create-mirinjs";
 
 const [command, arg] = Bun.argv.slice(2);
@@ -15,6 +16,7 @@ const USAGE = `mirin — build desktop apps with Bun + Chromium
 Usage:
   mirin dev          run the app against the Vite dev server (HMR + typed RPC)
   mirin build        package a standalone, signed .app (output: ./build)
+  mirin release      build + emit update artifacts (output: ./build/release)
   mirin init [dir]   scaffold a new app
 `;
 
@@ -24,7 +26,12 @@ switch (command) {
     break;
   }
   case "build": {
-    process.exit(await build());
+    await build();
+    process.exit(0);
+    break;
+  }
+  case "release": {
+    process.exit(await release());
     break;
   }
   case "init": {

package/src/release.ts

@@ -0,0 +1,85 @@
+/**
+ * `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.gz   the full bundle
+ *
+ * These names are flat (no folders) so they upload as-is to GitHub Releases,
+ * S3/R2, or any static host — whatever `release.baseUrl` points at. Channels
+ * coexist at the same baseUrl because the channel is part of every filename.
+ *
+ * The app's `app.updater` polls `{baseUrl}/{prefix}-update.json`, compares the
+ * advertised version to its own, downloads `url`, verifies `sha256`, then swaps
+ * the whole `.app` and relaunches. (A signed/notarized `.app` must be replaced
+ * whole — never modified in place — so the artifact is the entire bundle.)
+ */
+
+import { $ } from "bun";
+import { mkdirSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { build } from "./build.ts";
+
+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 platform = "darwin";
+  const arch = process.arch; // "arm64" | "x64"
+  const prefix = `${result.channel}-${platform}-${arch}`;
+  // Sanitize the app name for a URL-safe artifact filename (spaces break hosts).
+  const safeName = result.appName.replace(/[^A-Za-z0-9._-]/g, "");
+
+  const buildDir = join(projectDir, "build");
+  const outDir = join(buildDir, "release");
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  // Notarize + staple before packing (so the shipped bundle passes Gatekeeper on
+  // end-user machines), when notary credentials are present in the environment.
+  const apple = process.env.MIRIN_NOTARY_APPLE_ID;
+  const pw = process.env.MIRIN_NOTARY_PASSWORD;
+  const team = process.env.MIRIN_NOTARY_TEAM_ID;
+  if (apple && pw && team) {
+    console.log("[mirin release] notarizing (this can take a few minutes)…");
+    const zip = join(buildDir, "_notarize.zip");
+    await $`ditto -c -k --keepParent ${result.app} ${zip}`;
+    await $`xcrun notarytool submit ${zip} --apple-id ${apple} --password ${pw} --team-id ${team} --wait`;
+    await $`xcrun stapler staple ${result.app}`;
+    rmSync(zip, { force: true });
+  }
+
+  const tarName = `${prefix}-${safeName}.app.tar.gz`;
+  const tarPath = join(outDir, tarName);
+
+  console.log(`[mirin release] packing ${result.appName}.app → ${tarName}`);
+  // BSD tar preserves the CEF framework's symlinks + executable bits.
+  await $`tar -czf ${tarPath} -C ${buildDir} ${`${result.appName}.app`}`;
+
+  const bytes = readFileSync(tarPath);
+  const sha256 = new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
+
+  const manifest = {
+    version: result.version,
+    channel: result.channel,
+    platform,
+    arch,
+    url: tarName,
+    sha256,
+    size: bytes.byteLength,
+  };
+  const manifestName = `${prefix}-update.json`;
+  await Bun.write(join(outDir, manifestName), `${JSON.stringify(manifest, null, 2)}\n`);
+
+  const mb = (bytes.byteLength / 1e6).toFixed(1);
+  console.log(`\n[mirin release] done → build/release/`);
+  console.log(`  ${manifestName}`);
+  console.log(`  ${tarName} (${mb} MB)`);
+  console.log(`\nUpload both to: ${result.baseUrl}`);
+  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 });
+    }
+  }
+}