mirinjs 0.0.1-alpha.10 → 0.0.1-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirinjs",
-  "version": "0.0.1-alpha.10",
+  "version": "0.0.1-alpha.12",
   "description": "Build desktop apps with Bun, TypeScript, and Chromium (CEF). The Bun-native Electron alternative.",
   "type": "module",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "./config": "./src/config.ts",
     "./rpc": "./src/rpc.ts",
     "./client": "./src/client.ts",
+    "./codec": "./src/codec.ts",
     "./host": "./src/host.ts"
   },
   "files": [

package/src/app.ts

@@ -6,6 +6,8 @@
 import { runtime, onNativeEvent, resolveUrl, type NativeEvent } from "./runtime.ts";
 import type { Router, EventProc } from "./rpc.ts";
 import type { WindowConfig, WindowMaterial, WindowMaterialOptions } from "./config.ts";
+import { updater } from "./updater.ts";
+import type { Updater } from "./updater.ts";
 
 /** Which native backend a window's `material` resolved to. */
 export type WindowMaterialInfo = {
@@ -279,6 +281,9 @@ export interface Dock {
 class MirinApp extends Emitter<AppEvents> {
   readonly windows = new Windows();
 
+  /** Auto-updater (macOS). Inert unless the app was built with `release` set. */
+  readonly updater: Updater = updater;
+
   /** macOS Dock-icon controls. Hiding suits resident, hotkey-summoned apps. */
   readonly dock: Dock = {
     hide: () => this.#setDock(false),

package/src/codec.ts

@@ -0,0 +1,62 @@
+/**
+ * mirin/codec — thin bun:ffi bindings to libmirin_core's updater codec (zstd +
+ * bsdiff, file-path API). Used both at `mirin release` time (produce patches)
+ * and at runtime (apply them), loading the same dylib so compress/diff are
+ * byte-identical on both sides.
+ */
+
+import { dlopen, FFIType, ptr } from "bun:ffi";
+
+const SYMBOLS = {
+  mirin_zstd_compress_file: { args: [FFIType.ptr, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+  mirin_zstd_decompress_file: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+  mirin_bsdiff_file: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+  mirin_bspatch_file: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+} as const;
+
+function cstr(s: string): Uint8Array {
+  return new TextEncoder().encode(s + "\0");
+}
+
+export interface Codec {
+  /** zstd-compress `src` → `dst` at `level` (default 19). */
+  compress(src: string, dst: string, level?: number): void;
+  /** zstd-decompress `src` → `dst`. */
+  decompress(src: string, dst: string): void;
+  /** bsdiff: write a patch turning `oldPath` into `newPath`. */
+  diff(oldPath: string, newPath: string, patchPath: string): void;
+  /** bspatch: apply `patchPath` to `oldPath`, producing `newPath`. */
+  patch(oldPath: string, patchPath: string, newPath: string): void;
+}
+
+/** Load the codec from a libmirin_core dylib path. */
+export function loadCodec(dylibPath: string): Codec {
+  const { symbols } = dlopen(dylibPath, SYMBOLS);
+  const check = (rc: number, op: string) => {
+    if (rc !== 0) throw new Error(`codec ${op} failed (rc=${rc})`);
+  };
+  return {
+    compress(src, dst, level = 19) {
+      const s = cstr(src);
+      const d = cstr(dst);
+      check(symbols.mirin_zstd_compress_file(ptr(s), ptr(d), level), "compress");
+    },
+    decompress(src, dst) {
+      const s = cstr(src);
+      const d = cstr(dst);
+      check(symbols.mirin_zstd_decompress_file(ptr(s), ptr(d)), "decompress");
+    },
+    diff(oldPath, newPath, patchPath) {
+      const o = cstr(oldPath);
+      const n = cstr(newPath);
+      const p = cstr(patchPath);
+      check(symbols.mirin_bsdiff_file(ptr(o), ptr(n), ptr(p)), "diff");
+    },
+    patch(oldPath, patchPath, newPath) {
+      const o = cstr(oldPath);
+      const p = cstr(patchPath);
+      const n = cstr(newPath);
+      check(symbols.mirin_bspatch_file(ptr(o), ptr(p), ptr(n)), "patch");
+    },
+  };
+}

package/src/config.ts

@@ -86,9 +86,24 @@ export interface MirinConfig {
    * into an `.icns`. Embedded in the bundle for the Dock and Finder.
    */
   icon?: string;
+  /**
+   * Auto-update configuration (macOS). Omit to disable updates entirely.
+   * `baseUrl` is a flat directory of release artifacts (a GitHub Releases
+   * `…/releases/latest/download` URL, an S3/R2 bucket, or any static host).
+   * `channel` (default "stable") is baked into artifact filenames + the app's
+   * support folder, so multiple channels can coexist at the same `baseUrl`.
+   */
+  release?: ReleaseConfig;
   windows: Record<string, WindowConfig>;
 }
 
+export interface ReleaseConfig {
+  /** Flat directory URL hosting `{channel}-{platform}-{arch}-*` update files. */
+  baseUrl: string;
+  /** Update channel; baked into artifact names + support dir. Default "stable". */
+  channel?: string;
+}
+
 /** Identity function for typing/intellisense. `const` generic preserves window names as literal keys. */
 export function defineConfig<const T extends MirinConfig>(config: T): T {
   return config;

package/src/host.ts

@@ -48,7 +48,7 @@ const coreConfig = JSON.parse(
 const core = new Core(corePath);
 
 const worker = new Worker(workerPath, {
-  workerData: { corePath, manifest, devUrl: process.env.MIRIN_DEV_URL },
+  workerData: { corePath, manifest, devUrl: process.env.MIRIN_DEV_URL, resourcesDir },
 });
 worker.on("error", (err) => console.error("[mirin worker]", err));
 

package/src/index.ts

@@ -23,6 +23,7 @@ export { dialog } from "./dialog.ts";
 export { clipboard } from "./clipboard.ts";
 export { globalShortcut } from "./shortcut.ts";
 export { logger, setLogLevel, getLogLevel, Logger } from "./logger.ts";
+export { updater, Updater } from "./updater.ts";
 export { NotAttachedError } from "./runtime.ts";
 
 export type {
@@ -38,6 +39,7 @@ export type {
 } from "./app.ts";
 export type { MenuItemTemplate, MenuRole } from "./menu.ts";
 export type { LogLevel } from "./logger.ts";
+export type { UpdaterStatus, UpdateInfo, UpdateProgress, UpdaterEvents } from "./updater.ts";
 export type { TrayOptions } from "./tray.ts";
 export type { OpenDialogOptions, SaveDialogOptions, MessageDialogOptions } from "./dialog.ts";
 export type {

package/src/runtime.ts

@@ -18,6 +18,10 @@ export interface Runtime {
   rpc: RpcServer;
   manifestWindows: ManifestWindowConfig[];
   devUrl?: string;
+  /** Contents/Resources of the running .app (for the updater). Absent in dev. */
+  resourcesDir?: string;
+  /** Path to libmirin_core (for the updater codec). */
+  corePath?: string;
 }
 
 export class NotAttachedError extends Error {
@@ -79,6 +83,7 @@ export function boot(): void {
     corePath?: string;
     manifest?: { windows?: Record<string, WindowConfig> };
     devUrl?: string;
+    resourcesDir?: string;
   };
   const corePath = data.corePath ?? process.env.MIRIN_CORE;
   if (!corePath) return; // not under the host; the API stays detached
@@ -92,6 +97,13 @@ export function boot(): void {
     data.manifest?.windows ?? {},
   ).map(([name, cfg]) => ({ name, ...cfg }));
 
-  current = { core, rpc, manifestWindows, devUrl: data.devUrl };
+  current = {
+    core,
+    rpc,
+    manifestWindows,
+    devUrl: data.devUrl,
+    resourcesDir: data.resourcesDir,
+    corePath,
+  };
   core.onEvent(dispatch);
 }

package/src/updater.ts

@@ -0,0 +1,345 @@
+/**
+ * mirin/updater — the `app.updater` API (runs in the Bun Worker).
+ *
+ * Reads the app's `Resources/version.json` (embedded by `mirin build` when
+ * `release` is set), polls `{baseUrl}/{prefix}-update.json`, and when a different
+ * version is published downloads it, verifies its SHA-256, then swaps the whole
+ * `.app` and relaunches. Updates prefer a small **delta patch** (bsdiff) from the
+ * currently-installed version and fall back to the full bundle whenever a patch
+ * isn't usable.
+ *
+ * A signed/notarized `.app` cannot be modified in place without breaking its
+ * signature, so the whole bundle is always replaced. Updates run only in a
+ * packaged app with `release` set; in `mirin dev` the updater is idle.
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
+import { $ } from "bun";
+import { runtime } from "./runtime.ts";
+import { loadCodec } from "./codec.ts";
+
+export type UpdaterStatus =
+  | "idle"
+  | "checking"
+  | "update-available"
+  | "downloading"
+  | "applying"
+  | "complete"
+  | "error";
+
+/** The running app's embedded identity (Resources/version.json). */
+interface VersionInfo {
+  version: string;
+  channel: string;
+  baseUrl: string;
+  name: string;
+  identifier: string;
+}
+
+/** The published-release manifest ({prefix}-update.json). */
+interface Manifest {
+  version: string;
+  channel: string;
+  platform: string;
+  arch: string;
+  /** SHA-256 of the uncompressed bundle tar (update identity + integrity). */
+  tarHash: string;
+  bundle: { url: string; sha256: string; size?: number };
+  patches?: Array<{ fromVersion: string; url: string; sha256: string; size?: number }>;
+}
+
+/** A published release the running app can update to. */
+export interface UpdateInfo {
+  version: string;
+  currentVersion: string;
+  channel: string;
+}
+
+export interface UpdateProgress {
+  received: number;
+  total: number;
+  /** 0..1 (0 when total is unknown). */
+  fraction: number;
+}
+
+export type UpdaterEvents = {
+  status: { status: UpdaterStatus };
+  progress: UpdateProgress;
+  "update-available": UpdateInfo;
+  error: { message: string };
+};
+
+type Listener<P> = (payload: P) => void;
+
+export class Updater {
+  #listeners = new Map<keyof UpdaterEvents, Set<Listener<unknown>>>();
+  #status: UpdaterStatus = "idle";
+  #info: VersionInfo | null | undefined;
+  #manifest: Manifest | null = null;
+  #staged: string | null = null;
+  #autoCheck: ReturnType<typeof setInterval> | undefined;
+
+  on<K extends keyof UpdaterEvents>(type: K, listener: Listener<UpdaterEvents[K]>): () => void {
+    let set = this.#listeners.get(type);
+    if (!set) this.#listeners.set(type, (set = new Set()));
+    set.add(listener as Listener<unknown>);
+    return () => set!.delete(listener as Listener<unknown>);
+  }
+
+  get status(): UpdaterStatus {
+    return this.#status;
+  }
+  get currentVersion(): string {
+    return this.#version()?.version ?? "0.0.0";
+  }
+  get channel(): string {
+    return this.#version()?.channel ?? "stable";
+  }
+  /** Whether updates are configured (packaged build with `release` set). */
+  get enabled(): boolean {
+    return this.#version() != null;
+  }
+
+  /** Fetch the channel manifest; report an available update or `null`. Never throws. */
+  async checkForUpdate(): Promise<UpdateInfo | null> {
+    const v = this.#version();
+    if (!v) return null;
+    this.#setStatus("checking");
+    try {
+      const url = `${v.baseUrl.replace(/\/$/, "")}/${this.#prefix()}-update.json?t=${Date.now()}`;
+      const res = await fetch(url, { redirect: "follow" });
+      if (!res.ok) throw new Error(`manifest ${res.status}`);
+      const m = (await res.json()) as Manifest;
+      if (!m.version || m.version === v.version) {
+        this.#manifest = null;
+        this.#setStatus("idle");
+        return null;
+      }
+      this.#manifest = m;
+      const info: UpdateInfo = { version: m.version, currentVersion: v.version, channel: v.channel };
+      this.#setStatus("update-available");
+      this.#emit("update-available", info);
+      return info;
+    } catch (err) {
+      this.#fail(err);
+      return null;
+    }
+  }
+
+  /**
+   * Download + verify the pending update — a delta patch from the installed
+   * version when available, else the full bundle. Emits `progress`.
+   */
+  async download(onProgress?: (p: UpdateProgress) => void): Promise<void> {
+    const v = this.#version();
+    const m = this.#manifest;
+    if (!v || !m) throw new Error("no update to download — call checkForUpdate() first");
+    this.#setStatus("downloading");
+    try {
+      const codec = loadCodec(this.#corePath());
+      const support = this.#supportDir(v);
+      const tarsDir = join(support, "tars");
+      const work = join(support, "updates");
+      mkdirSync(tarsDir, { recursive: true });
+      rmSync(work, { recursive: true, force: true });
+      mkdirSync(work, { recursive: true });
+
+      const base = v.baseUrl.replace(/\/$/, "");
+      const newTar = join(work, "new.tar");
+      const cachedTar = join(tarsDir, `${v.version}.tar`);
+      const patch = m.patches?.find((p) => p.fromVersion === v.version);
+
+      let ok = false;
+      if (patch && existsSync(cachedTar)) {
+        try {
+          const patchZst = join(work, "patch.zst");
+          await this.#fetchToFile(`${base}/${patch.url}`, patchZst, patch.sha256, onProgress);
+          const patchRaw = join(work, "patch.bin");
+          codec.decompress(patchZst, patchRaw);
+          codec.patch(cachedTar, patchRaw, newTar); // bspatch
+          await this.#verify(newTar, m.tarHash);
+          ok = true;
+        } catch {
+          ok = false; // delta failed → full bundle
+        }
+      }
+      if (!ok) {
+        const bundleZst = join(work, "bundle.tar.zst");
+        await this.#fetchToFile(`${base}/${m.bundle.url}`, bundleZst, m.bundle.sha256, onProgress);
+        codec.decompress(bundleZst, newTar);
+        await this.#verify(newTar, m.tarHash);
+      }
+
+      // Cache the new tar (for the next delta) and extract for swapping.
+      const keepTar = join(tarsDir, `${m.version}.tar`);
+      rmSync(keepTar, { force: true });
+      renameSync(newTar, keepTar);
+      await $`tar -xf ${keepTar} -C ${work}`.quiet();
+      const staged = join(work, `${v.name}.app`);
+      if (!existsSync(staged)) throw new Error(`extracted bundle not found at ${staged}`);
+
+      const verify = await $`codesign --verify --deep --strict ${staged}`.quiet().nothrow();
+      if (verify.exitCode !== 0) throw new Error("codesign verification failed on the downloaded update");
+
+      // Keep only the newest cached tar.
+      for (const f of readdirSync(tarsDir)) {
+        if (f !== `${m.version}.tar`) rmSync(join(tarsDir, f), { force: true });
+      }
+
+      this.#staged = staged;
+      this.#setStatus("update-available");
+    } catch (err) {
+      this.#fail(err);
+      throw err;
+    }
+  }
+
+  /** Swap the running `.app` with the downloaded bundle and relaunch. */
+  async applyAndRelaunch(): Promise<void> {
+    const v = this.#version();
+    if (!v || !this.#staged) throw new Error("no staged update — call download() first");
+    this.#setStatus("applying");
+    try {
+      const runningApp = join(this.#resourcesDir()!, "..", "..");
+      const script = [
+        `APP=${sh(runningApp)}`,
+        `NEW=${sh(this.#staged)}`,
+        `PID=${process.pid}`,
+        `while kill -0 "$PID" 2>/dev/null; do sleep 0.2; done`,
+        `sleep 0.3`,
+        `rm -rf "$APP"`,
+        `mv "$NEW" "$APP"`,
+        `xattr -r -d com.apple.quarantine "$APP" 2>/dev/null || true`,
+        `open "$APP"`,
+      ].join("\n");
+
+      Bun.spawn(["/bin/sh", "-c", script], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+      }).unref();
+
+      this.#setStatus("complete");
+      runtime().core.quit();
+    } catch (err) {
+      this.#fail(err);
+      throw err;
+    }
+  }
+
+  /** Poll for updates every `intervalMs`. Returns a stop function. */
+  startAutoCheck(intervalMs = 6 * 60 * 60 * 1000): () => void {
+    this.stopAutoCheck();
+    void this.checkForUpdate();
+    this.#autoCheck = setInterval(() => void this.checkForUpdate(), intervalMs);
+    return () => this.stopAutoCheck();
+  }
+
+  stopAutoCheck(): void {
+    if (this.#autoCheck) clearInterval(this.#autoCheck);
+    this.#autoCheck = undefined;
+  }
+
+  // ---- internals ----
+
+  async #fetchToFile(
+    url: string,
+    dest: string,
+    expectedSha: string,
+    onProgress?: (p: UpdateProgress) => void,
+  ): Promise<void> {
+    const res = await fetch(url, { redirect: "follow" });
+    if (!res.ok || !res.body) throw new Error(`download ${res.status}`);
+    const total = Number(res.headers.get("content-length") ?? 0);
+    const reader = res.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let received = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      received += value.byteLength;
+      const p: UpdateProgress = { received, total, fraction: total ? received / total : 0 };
+      this.#emit("progress", p);
+      onProgress?.(p);
+    }
+    const buf = Buffer.concat(chunks);
+    const got = new Bun.CryptoHasher("sha256").update(buf).digest("hex");
+    if (got !== expectedSha) throw new Error("download hash mismatch");
+    await Bun.write(dest, buf);
+  }
+
+  async #verify(file: string, expectedSha: string): Promise<void> {
+    const buf = await Bun.file(file).bytes();
+    const got = new Bun.CryptoHasher("sha256").update(buf).digest("hex");
+    if (got !== expectedSha) throw new Error("reconstructed bundle hash mismatch");
+  }
+
+  #version(): VersionInfo | null {
+    if (this.#info !== undefined) return this.#info;
+    const dir = this.#resourcesDir();
+    const path = dir ? join(dir, "version.json") : undefined;
+    if (path && existsSync(path)) {
+      try {
+        this.#info = JSON.parse(readFileSync(path, "utf8")) as VersionInfo;
+      } catch {
+        this.#info = null;
+      }
+    } else {
+      this.#info = null;
+    }
+    return this.#info;
+  }
+
+  #resourcesDir(): string | undefined {
+    try {
+      return runtime().resourcesDir;
+    } catch {
+      return undefined;
+    }
+  }
+
+  #corePath(): string {
+    const p = runtime().corePath;
+    if (!p) throw new Error("libmirin_core path unavailable");
+    return p;
+  }
+
+  #prefix(): string {
+    return `${this.#version()!.channel}-darwin-${process.arch}`;
+  }
+
+  #supportDir(v: VersionInfo): string {
+    return join(homedir(), "Library", "Application Support", v.identifier, v.channel);
+  }
+
+  #setStatus(status: UpdaterStatus): void {
+    this.#status = status;
+    this.#emit("status", { status });
+  }
+
+  #fail(err: unknown): void {
+    const message = err instanceof Error ? err.message : String(err);
+    this.#status = "error";
+    this.#emit("status", { status: "error" });
+    this.#emit("error", { message });
+  }
+
+  #emit<K extends keyof UpdaterEvents>(type: K, payload: UpdaterEvents[K]): void {
+    this.#listeners.get(type)?.forEach((fn) => fn(payload));
+    try {
+      runtime().rpc.broadcast(`mirin:updater:${type}`, payload);
+    } catch {
+      // detached / rpc not up — ignore
+    }
+  }
+}
+
+/** Single-quote a path for safe interpolation into a /bin/sh script. */
+function sh(p: string): string {
+  return `'${p.replace(/'/g, `'\\''`)}'`;
+}
+
+export const updater = new Updater();