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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirinjs/cli",
-  "version": "0.0.1-alpha.10",
+  "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.10"
+    "create-mirinjs": "0.0.1-alpha.11"
   },
   "optionalDependencies": {
-    "@mirinjs/darwin-arm64": "0.0.1-alpha.10"
+    "@mirinjs/darwin-arm64": "0.0.1-alpha.11"
   },
   "publishConfig": {
     "access": "public"

package/src/build.ts

@@ -16,13 +16,37 @@
  */
 
 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 });
@@ -33,8 +57,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 +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,
@@ -61,16 +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,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,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;
+}