@mirinjs/cli 0.0.1-alpha.10 → 0.0.1-alpha.12

package/package.json

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

package/src/build.ts

@@ -16,13 +16,39 @@
  */
 
 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;
+  /** libmirin_core path (for the updater codec at release time). */
+  coreDylib: 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 });
@@ -33,8 +59,11 @@ export async function build(projectDir = process.cwd()): Promise<number> {
   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…");
@@ -53,6 +82,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,
@@ -61,16 +95,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, coreDylib: artifacts.coreDylib };
 }

package/src/bundle.ts

@@ -33,6 +33,8 @@ 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. */
@@ -42,6 +44,7 @@ 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)
   };
 }
 
@@ -136,6 +139,7 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
   // 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",
@@ -145,8 +149,8 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
     CFBundleInfoDictionaryVersion: "6.0",
     CFBundleName: appName,
     CFBundlePackageType: "APPL",
-    CFBundleShortVersionString: "0.0.1",
-    CFBundleVersion: "0.0.1",
+    CFBundleShortVersionString: version,
+    CFBundleVersion: version,
     LSMinimumSystemVersion: "13.0",
     NSHighResolutionCapable: true,
     NSSupportsAutomaticGraphicsSwitching: true,
@@ -173,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}`;
@@ -189,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/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,131 @@
+/**
+ * `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 { 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 platform = "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(/\/$/, "");
+
+  const buildDir = join(projectDir, "build");
+  const outDir = join(buildDir, "release");
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  // Optional notarize + staple (Developer ID) before packing, when configured.
+  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 codec = loadCodec(result.coreDylib);
+
+  // Uncompressed tar — the identity + diff/patch basis (BSD tar keeps symlinks).
+  const newTar = join(outDir, "_new.tar");
+  await $`tar -cf ${newTar} -C ${buildDir} ${`${result.appName}.app`}`;
+  const tarHash = sha256File(newTar);
+
+  // Full bundle: zstd(newTar).
+  const bundleName = `${prefix}-${safeName}.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`);
+
+  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})`);
+  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;
+}