@sixb/desktop 0.0.0-stage → 0.2.0

package/dist/shell/navigation.d.ts

@@ -0,0 +1,39 @@
+/** What the shell was built to open. Written into the app by `writeDesktopApp`. */
+export interface ShellConfig {
+    /** Shown in the title bar, and to the user approving this window's sign-in. */
+    readonly name: string;
+    /** The app, such as `https://app.example.com/`. */
+    readonly appUrl: string;
+    readonly apiOrigin: string;
+}
+export interface NavigationState {
+    /** Approval pages already opened, so a waiting page that reloads opens its browser tab once. */
+    readonly openedCodes: Set<string>;
+    lastSignIn: {
+        readonly url: string;
+        readonly at: number;
+    } | null;
+}
+export type NavigationStep = 
+/** Send the window somewhere else instead. */
+{
+    readonly kind: "load";
+    readonly url: string;
+}
+/** Hand a URL to the system browser. */
+ | {
+    readonly kind: "open-external";
+    readonly url: string;
+};
+export declare function createNavigationState(): NavigationState;
+/**
+ * Decides what the shell does about a navigation of its window.
+ *
+ * The window is a browser the user cannot finish a sign-in in: a magic link opens in their own
+ * browser, and identity providers turn embedded ones away. So the app's ordinary sign-in redirect
+ * becomes a request to be approved from the system browser, and the approval page opens there.
+ */
+export declare function nextNavigationStep(config: ShellConfig, state: NavigationState, navigatedTo: string, now?: number): NavigationStep | null;
+/** Only web addresses leave for the system browser; a page cannot make the shell launch programs. */
+export declare function isWebUrl(value: string): boolean;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/shell/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/shell/navigation.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,gGAAgG;IAChG,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACjC,UAAU,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACjE;AAED,MAAM,MAAM,cAAc;AACxB,8CAA8C;AAC5C;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE;AACjD,wCAAwC;GACtC;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAM5D,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,eAAe,EACtB,WAAW,EAAE,MAAM,EACnB,GAAG,GAAE,MAAmB,GACvB,cAAc,GAAG,IAAI,CAgCvB;AAED,qGAAqG;AACrG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAO/C"}

package/dist/shell/preload.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preload.d.ts.map

package/dist/shell/preload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../src/shell/preload.ts"],"names":[],"mappings":""}

package/dist/shell/window.d.ts

@@ -0,0 +1,48 @@
+import type { ShellConfig } from "./navigation";
+/**
+ * Whether the window itself may show `url`: only the app and the API that serves its sign-in
+ * pages. Anything else a page links to opens in the user's browser instead.
+ */
+export declare function mayNavigate(config: ShellConfig, url: string): boolean;
+/**
+ * Whether `url` is on the app's own origin. Camera, location and the like are the app's to ask for,
+ * and not a frame it embeds from elsewhere.
+ */
+export declare function isAppUrl(config: ShellConfig, url: string): boolean;
+/**
+ * What the window paints before a page has: the loading page's own background, so the window
+ * opens, and passes from that page to the app, without a flash of white.
+ */
+export declare const WINDOW_BACKGROUND: {
+    readonly light: "#fafafa";
+    readonly dark: "#0a0a0a";
+};
+/**
+ * What the window's page runs with. The page is remote: it gets no Node and a world apart from the
+ * preload's, on every platform, and reaches the shell only through what the preload exposes.
+ */
+export declare function pageWebPreferences(preload: string): {
+    sandbox: boolean;
+    contextIsolation: boolean;
+    nodeIntegration: boolean;
+    preload: string;
+};
+/** Only macOS draws window controls over the page; elsewhere the title bar stays. */
+export declare function hasHiddenTitleBar(platform: NodeJS.Platform): boolean;
+/** The band at the top of a window without a title bar where macOS draws the window controls. */
+export declare const CONTROLS_HEIGHT_PX = 36;
+/**
+ * Styles for a window without a title bar, inserted into every page it shows.
+ *
+ * The page reaches the top edge, under the window controls, so two things a title bar did have
+ * to come from the page: somewhere to grab the window, and room for the controls.
+ *  - `#sixb-desktop-drag` (added by the preload) is the drag handle: a strip across the top, above
+ *    the page. It ignores the pointer, and every control is cut out of the draggable area, so
+ *    buttons and links under the strip still take their clicks and the space between them moves
+ *    the window. Something clickable that is none of the things listed here needs
+ *    `-webkit-app-region: no-drag` of its own.
+ *  - The shared sidebar is moved down so most apps need nothing. Other layouts can use
+ *    `html[data-sixb-desktop]` and `--sixb-desktop-controls-height`, which the preload sets.
+ */
+export declare const HIDDEN_TITLE_BAR_CSS: string;
+//# sourceMappingURL=window.d.ts.map

package/dist/shell/window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../src/shell/window.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAOrE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAMlE;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;CAAiD,CAAA;AAE/E;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM;;;;;EAEjD;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,OAAO,CAEpE;AAED,iGAAiG;AACjG,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,QAsBvB,CAAA"}

package/dist/tsconfig.json

@@ -0,0 +1,5 @@
+// Written by scripts/build-package.ts, and published on purpose.
+// Bun applies the nearest tsconfig paths map to every import it resolves, node_modules
+// included. An empty map here keeps a consumer's aliases from sending a module in this
+// directory back into a second copy of its own source.
+{ "compilerOptions": { "paths": {} } }

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@sixb/desktop",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Ship a Sixb project's app as a desktop app",
+  "keywords": [
+    "sixb",
+    "bun",
+    "desktop",
+    "electron"
+  ],
+  "homepage": "https://sixb.ai",
+  "bugs": {
+    "url": "https://github.com/sixb-ai/sixb/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sixb-ai/sixb.git",
+    "directory": "packages/desktop"
+  },
+  "author": "Sixb contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-package.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "@electron/packager": "^20.3.0",
+    "electron": "^44.9.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "bun": ">=1.4.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/generate.ts

@@ -0,0 +1,133 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { readAppIdentity } from "./identity"
+import { drawMacIcon } from "./mac-icon"
+import { run } from "./run"
+import type { ShellConfig } from "./shell/navigation"
+
+export interface DesktopAppOptions {
+  /** The Sixb project. The desktop app is generated under its `.sixb/desktop`. */
+  readonly projectRoot: string
+  /** Where the app is served. The window opens it; the desktop app takes its name and icon from it. */
+  readonly appUrl: string
+  /** The project's API. Its sign-in pages are where the window is approved. */
+  readonly apiOrigin: string
+}
+
+/** The Electron app `writeDesktopApp` generated, and what it is called. */
+export interface GeneratedApp {
+  readonly dir: string
+  readonly name: string
+  readonly version: string
+  /** The app's icon in `dir`, when it declares one. */
+  readonly icon: string | null
+}
+
+// Read from the package's `src`, which ships, whether this module runs from `src` or `dist`.
+const SHELL_SOURCE_DIR = fileURLToPath(new URL("../src/shell", import.meta.url))
+
+/** Where a project's desktop app is generated (`app`) and packaged (`dist`). */
+export function desktopDir(projectRoot: string, part: "app" | "dist"): string {
+  return join(projectRoot, ".sixb", "desktop", part)
+}
+
+/**
+ * Writes the Electron app that opens `appUrl` into the project's `.sixb/desktop/app`. The directory
+ * is build-owned, like the rest of `.sixb`: it is cleared on every call.
+ */
+export async function writeDesktopApp(options: DesktopAppOptions): Promise<GeneratedApp> {
+  const identity = await readAppIdentity(options.appUrl)
+  const version = await readProjectVersion(options.projectRoot)
+  const dir = desktopDir(options.projectRoot, "app")
+  await rm(dir, { recursive: true, force: true })
+  await mkdir(dir, { recursive: true })
+
+  const config: ShellConfig = {
+    name: identity.name,
+    appUrl: new URL(options.appUrl).href,
+    apiOrigin: new URL(options.apiOrigin).origin,
+  }
+  const manifest = {
+    name: "sixb-desktop-app",
+    // Names the folder the window's cookies are kept in, so each app has its own sign-in.
+    productName: identity.name,
+    version,
+    private: true,
+    main: "main.js",
+  }
+  const icon = identity.icon ? await writeIcon(dir, identity.icon) : null
+  const template = await readFile(join(SHELL_SOURCE_DIR, "index.html"), "utf-8")
+  await Promise.all([
+    writeFile(join(dir, "package.json"), `${JSON.stringify(manifest, null, 2)}\n`),
+    writeFile(join(dir, "shell.json"), `${JSON.stringify(config, null, 2)}\n`),
+    writeFile(join(dir, "index.html"), renderShellPage(template, { ...config, icon: !!icon })),
+  ])
+
+  // Electron loads plain JavaScript. A child process, because an in-process `Bun.build()` that
+  // wedges takes its caller down with it.
+  await run(
+    [
+      process.execPath,
+      "build",
+      join(SHELL_SOURCE_DIR, "main.ts"),
+      join(SHELL_SOURCE_DIR, "preload.ts"),
+      "--target=node",
+      "--format=cjs",
+      "--external=electron",
+      `--outdir=${dir}`,
+    ],
+    "Could not compile the desktop shell."
+  )
+  return { dir, name: identity.name, version, icon }
+}
+
+/** The page the window shows while the app loads, and when it cannot reach the app. */
+export function renderShellPage(
+  template: string,
+  page: { readonly name: string; readonly appUrl: string; readonly icon: boolean }
+): string {
+  const initial = Array.from(page.name.trim())[0]?.toUpperCase() ?? ""
+  const markup: Record<string, string> = {
+    name: escapeHtml(page.name),
+    host: escapeHtml(new URL(page.appUrl).host),
+    appUrl: escapeHtml(page.appUrl),
+    // The app's icon, or the first letter of its name standing in for one.
+    mark: page.icon
+      ? '<img class="mark" src="icon.png" alt="" />'
+      : `<div class="mark" aria-hidden="true">${escapeHtml(initial)}</div>`,
+  }
+  return template.replaceAll(/\{\{(\w+)\}\}/g, (_match, key: string) => markup[key] ?? "")
+}
+
+/** Writes the app's icon into `dir` as `icon.png`; on macOS, drawn the way macOS draws app icons. */
+async function writeIcon(dir: string, png: Uint8Array): Promise<string> {
+  const icon = join(dir, "icon.png")
+  if (process.platform !== "darwin") {
+    await writeFile(icon, png)
+    return icon
+  }
+  // The original goes beside the app, not in it: everything in the app's directory ships.
+  const source = join(dir, "..", "icon-source.png")
+  await writeFile(source, png)
+  await drawMacIcon(source, icon)
+  return icon
+}
+
+async function readProjectVersion(projectRoot: string): Promise<string> {
+  try {
+    const manifest: unknown = JSON.parse(await readFile(join(projectRoot, "package.json"), "utf-8"))
+    const version = (manifest as { readonly version?: unknown } | null)?.version
+    return typeof version === "string" ? version : "0.0.0"
+  } catch {
+    return "0.0.0"
+  }
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+}

package/src/identity.ts

@@ -0,0 +1,83 @@
+/** What the desktop app takes from the web app it opens. */
+export interface AppIdentity {
+  /** The app's name: `metadata.title` in `app/layout.tsx`. */
+  readonly name: string
+  /**
+   * The app's maskable icon, such as `app/public/icon-maskable-512.png`, or else its largest PNG
+   * icon, such as `app/public/icon-512.png`.
+   */
+  readonly icon: Uint8Array | null
+}
+
+/**
+ * Reads the app's web app manifest, the one a browser installs the app from. The desktop app is
+ * the same app installed another way, so it takes the same name and icon and has no settings of
+ * its own.
+ */
+export async function readAppIdentity(appUrl: string): Promise<AppIdentity> {
+  const manifestUrl = new URL("/app.webmanifest", appUrl)
+  const manifest: unknown = await (await fetchFromApp(manifestUrl)).json()
+  const { name, icons } = (typeof manifest === "object" && manifest !== null ? manifest : {}) as {
+    readonly name?: unknown
+    readonly icons?: unknown
+  }
+
+  const iconUrl = desktopIcon(icons, manifestUrl)
+  return {
+    name: typeof name === "string" && name.trim() ? name.trim() : "Sixb",
+    icon: iconUrl ? new Uint8Array(await (await fetchFromApp(iconUrl)).arrayBuffer()) : null,
+  }
+}
+
+/**
+ * The app's id on the desktop, from the address it opens: `https://orders.acme.com` becomes
+ * `com.acme.orders`. Each deployment gets its own, so a staging build installs beside production.
+ */
+export function bundleIdentifier(appUrl: string): string {
+  const labels = new URL(appUrl).hostname
+    .split(".")
+    .reverse()
+    .map((label) => label.toLowerCase().replaceAll(/[^a-z0-9-]/g, "-"))
+    .filter(Boolean)
+  return (labels.length > 1 ? labels : ["local", ...labels]).join(".")
+}
+
+// A maskable icon is drawn to its edges for a platform to cut its own shape from, which is what
+// macOS does with it. Any other icon may carry its own shape and margins.
+function desktopIcon(icons: unknown, manifestUrl: URL): URL | null {
+  let best: { readonly url: URL; readonly rank: readonly [number, number] } | null = null
+  for (const icon of Array.isArray(icons) ? icons : []) {
+    if (typeof icon !== "object" || icon === null) continue
+    const { src, sizes, type, purpose } = icon as Record<string, unknown>
+    if (typeof src !== "string") continue
+    const url = new URL(src, manifestUrl)
+    if (type === undefined ? !url.pathname.endsWith(".png") : type !== "image/png") continue
+
+    const maskable = typeof purpose === "string" && purpose.split(/\s+/).includes("maskable")
+    const size = Math.max(
+      0,
+      ...(typeof sizes === "string" ? sizes.split(/\s+/) : []).map(
+        (entry) => Number.parseInt(entry, 10) || 0
+      )
+    )
+    const rank = [maskable ? 1 : 0, size] as const
+    if (!best || rank[0] > best.rank[0] || (rank[0] === best.rank[0] && rank[1] > best.rank[1])) {
+      best = { url, rank }
+    }
+  }
+  return best?.url ?? null
+}
+
+async function fetchFromApp(url: URL): Promise<Response> {
+  let response: Response
+  try {
+    response = await fetch(url)
+  } catch (error) {
+    throw new Error(
+      `[SixbDesktop] Could not reach ${url} (${error instanceof Error ? error.message : error}). ` +
+        "The desktop app takes its name and icon from the app, so the app must be running there."
+    )
+  }
+  if (!response.ok) throw new Error(`[SixbDesktop] ${url} answered ${response.status}.`)
+  return response
+}

package/src/index.ts

@@ -0,0 +1,177 @@
+import { mkdir, readdir, rm } from "node:fs/promises"
+import { createRequire } from "node:module"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { type DesktopAppOptions, desktopDir, writeDesktopApp } from "./generate"
+import { bundleIdentifier } from "./identity"
+import { run } from "./run"
+
+export type { DesktopAppOptions } from "./generate"
+
+export interface DesktopWindow {
+  /** Resolves with Electron's exit code once the user quits it. */
+  readonly exited: Promise<number>
+  close(): void
+}
+
+export interface DesktopBuild {
+  /** What to hand to users: a zip of the app on macOS, the app's folder elsewhere. */
+  readonly path: string
+  /** Whether it was signed and notarized, and so opens without a warning. */
+  readonly signed: boolean
+}
+
+const packageRequire = createRequire(import.meta.url)
+// From the package's `src`, like the shell: see `SHELL_SOURCE_DIR`.
+const PACKAGER_SCRIPT = fileURLToPath(new URL("../src/packager.mjs", import.meta.url))
+
+/** Opens the app in a desktop window. `sixb dev --desktop` calls this. */
+export async function openDesktopApp(options: DesktopAppOptions): Promise<DesktopWindow> {
+  const app = await writeDesktopApp(options)
+  // Chromium writes plenty to stderr when all is well, so it goes to a file, named if the window
+  // quits on its own with an error.
+  const log = join(dirname(app.dir), "electron.log")
+  const electron = Bun.spawn([electronBinary(), app.dir], {
+    stdio: ["ignore", "ignore", Bun.file(log)],
+  })
+  let closing = false
+  const exited = electron.exited.then((code) => {
+    if (code !== 0 && !closing) {
+      console.error(`[SixbDesktop] The desktop window quit with exit code ${code}. See ${log}.`)
+    }
+    return code
+  })
+  return {
+    exited,
+    close: () => {
+      closing = true
+      electron.kill()
+    },
+  }
+}
+
+/** Packages the app for this machine's platform. `sixb desktop build` calls this. */
+export async function buildDesktopApp(options: DesktopAppOptions): Promise<DesktopBuild> {
+  const app = await writeDesktopApp(options)
+  const out = desktopDir(options.projectRoot, "dist")
+  await rm(out, { recursive: true, force: true })
+
+  const mac = process.platform === "darwin"
+  const notarize = mac ? appleNotarization() : null
+  const packaged = await packageApp({
+    dir: app.dir,
+    name: app.name,
+    out,
+    appBundleId: bundleIdentifier(options.appUrl),
+    appVersion: app.version,
+    electronVersion: (packageRequire("electron/package.json") as { readonly version: string })
+      .version,
+    ...(mac && app.icon ? { icon: await macIcon(app.icon) } : {}),
+    // Signs with the Developer ID certificate in the keychain, which notarization requires.
+    ...(notarize ? { osxSign: {}, osxNotarize: notarize } : {}),
+  })
+  if (!mac) return { path: packaged, signed: false }
+
+  const name = (await readdir(packaged)).find((entry) => entry.endsWith(".app"))
+  if (!name) throw new Error(`[SixbDesktop] The packaged app is missing from ${packaged}.`)
+  const bundle = join(packaged, name)
+  // Packaging breaks the ad-hoc signature Electron ships with. macOS calls a downloaded app with a
+  // broken signature damaged, and offers no way to open it; signed ad hoc, it can be allowed.
+  if (!notarize) {
+    await run(["codesign", "--force", "--deep", "--sign", "-", bundle], "Could not sign the app.")
+  }
+  // `ditto`, not `zip`: it keeps the bundle's symlinks, and with them its signature.
+  const zip = `${packaged}.zip`
+  await run(["ditto", "-c", "-k", "--keepParent", bundle, zip], "Could not zip the app.")
+  return { path: zip, signed: notarize !== null }
+}
+
+/**
+ * An App Store Connect API key, which notarizes the app so macOS opens it without a warning.
+ * Without one, the app is built unsigned.
+ */
+function appleNotarization(): {
+  readonly appleApiKey: string
+  readonly appleApiKeyId: string
+  readonly appleApiIssuer: string
+} | null {
+  const { APPLE_API_KEY, APPLE_API_KEY_ID, APPLE_API_ISSUER } = process.env
+  if (!APPLE_API_KEY && !APPLE_API_KEY_ID && !APPLE_API_ISSUER) return null
+  if (!APPLE_API_KEY || !APPLE_API_KEY_ID || !APPLE_API_ISSUER) {
+    throw new Error(
+      "[SixbDesktop] Set all of APPLE_API_KEY, APPLE_API_KEY_ID and APPLE_API_ISSUER to sign the " +
+        "macOS app, or none of them to build it unsigned."
+    )
+  }
+  return {
+    appleApiKey: APPLE_API_KEY,
+    appleApiKeyId: APPLE_API_KEY_ID,
+    appleApiIssuer: APPLE_API_ISSUER,
+  }
+}
+
+/**
+ * The packager wants `.icns`: every size macOS shows, scaled from the 1024-pixel icon, in one file.
+ * `sips` and `iconutil` ship with every Mac. Written beside the app, not in it: everything in the
+ * app's directory ships inside the bundle.
+ */
+async function macIcon(png: string): Promise<string> {
+  const desktop = dirname(dirname(png))
+  const iconset = join(desktop, "icon.iconset")
+  await rm(iconset, { recursive: true, force: true })
+  await mkdir(iconset)
+  const sizes = [16, 32, 128, 256, 512].flatMap((points) => [
+    { name: `icon_${points}x${points}.png`, pixels: points },
+    { name: `icon_${points}x${points}@2x.png`, pixels: points * 2 },
+  ])
+  await Promise.all(
+    sizes.map(({ name, pixels }) =>
+      run(
+        ["sips", "-z", `${pixels}`, `${pixels}`, png, "--out", join(iconset, name)],
+        "Could not scale the icon."
+      )
+    )
+  )
+  const icns = join(desktop, "icon.icns")
+  await run(["iconutil", "-c", "icns", iconset, "-o", icns], "Could not convert the icon.")
+  return icns
+}
+
+/**
+ * Runs `@electron/packager` into `options.out`, which starts empty, and resolves with the one
+ * directory it wrote there. Under Electron's own binary, which doubles as the Node the packager was
+ * written for: under Bun, the packager fails whenever it verifies a download (its checksum
+ * dependency does not load).
+ */
+async function packageApp(
+  options: { readonly out: string } & Record<string, unknown>
+): Promise<string> {
+  const packager = Bun.spawn(
+    [electronBinary(), PACKAGER_SCRIPT, JSON.stringify({ ...options, quiet: true })],
+    {
+      stdio: ["ignore", "inherit", "inherit"],
+      // Without the second, Electron's file system reads the `app.asar` the packager writes as a
+      // directory.
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", ELECTRON_NO_ASAR: "1" },
+    }
+  )
+  if ((await packager.exited) !== 0) {
+    throw new Error("[SixbDesktop] Packaging failed. See the output above.")
+  }
+  const [written] = await readdir(options.out)
+  if (!written) throw new Error(`[SixbDesktop] The packager wrote nothing to ${options.out}.`)
+  return join(options.out, written)
+}
+
+// Outside Electron, `require("electron")` is the path of the binary its install script fetched.
+function electronBinary(): string {
+  try {
+    return packageRequire("electron") as string
+  } catch {
+    const electronDir = dirname(packageRequire.resolve("electron/package.json"))
+    throw new Error(
+      "[SixbDesktop] Electron's binary is missing: its install script did not run. " +
+        `Run \`bun run --cwd ${electronDir} postinstall\`, then try again.`
+    )
+  }
+}

package/src/mac-icon.ts

@@ -0,0 +1,81 @@
+import { run } from "./run"
+
+/**
+ * Draws `png` the way macOS draws app icons, into `out`: on Apple's grid, a rounded square of 824
+ * pixels with continuous corners in a canvas of 1024, over the soft shadow Apple's own icons have.
+ * An icon drawn to its edges otherwise stands larger than every other icon in the Dock.
+ */
+export async function drawMacIcon(png: string, out: string): Promise<void> {
+  await run(
+    ["osascript", "-l", "JavaScript", "-e", MAC_ICON_SCRIPT, png, out],
+    "Could not draw the macOS icon."
+  )
+}
+
+// AppKit, through the JavaScript `osascript` runs, which every Mac has. The corner is the curve
+// UIKit rounds continuous corners with; with this radius it matches the outline of Apple's Notes
+// icon to a few pixels, and the shadow matches its shadow.
+const MAC_ICON_SCRIPT = `
+ObjC.import("AppKit")
+ObjC.import("CoreGraphics")
+
+function run([input, output]) {
+  const canvas = 1024
+  const body = 824
+  const radius = 185.4
+  const min = (canvas - body) / 2
+  const max = min + body
+
+  // One corner, as offsets in radii from the edge it leaves and the edge it joins.
+  const corner = [
+    [[1.52866483, 0]],
+    [[0.66993427, 0.065496], [1.08849323, 0], [0.86840689, 0.02065986]],
+    [[0.63149399, 0.074911]],
+    [[0.074911, 0.63149399], [0.37282392, 0.16906933], [0.16906933, 0.37282392]],
+    [[0.065496, 0.66993427]],
+    [[0, 1.52866483], [0.02065986, 0.86840689], [0, 1.08849323]],
+  ]
+  const corners = [
+    ([u, v]) => $.NSMakePoint(max - u * radius, max - v * radius),
+    ([u, v]) => $.NSMakePoint(max - v * radius, min + u * radius),
+    ([u, v]) => $.NSMakePoint(min + u * radius, min + v * radius),
+    ([u, v]) => $.NSMakePoint(min + v * radius, max - u * radius),
+  ]
+  const shape = $.NSBezierPath.bezierPath
+  shape.moveToPoint(corners[3]([0, 1.52866483]))
+  for (const at of corners) {
+    for (const [to, c1, c2] of corner) {
+      if (c1) shape.curveToPointControlPoint1ControlPoint2(at(to), at(c1), at(c2))
+      else shape.lineToPoint(at(to))
+    }
+  }
+  shape.closePath
+
+  const image = $.NSImage.alloc.initWithContentsOfFile(input)
+  if (image.isNil()) throw new Error("Cannot read " + input)
+  const bitmap = $.NSBitmapImageRep.alloc
+    .initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBytesPerRowBitsPerPixel(
+      null, canvas, canvas, 8, 4, true, false, $.NSDeviceRGBColorSpace, 0, 0
+    )
+  const context = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(bitmap)
+  $.NSGraphicsContext.setCurrentContext(context)
+  context.setImageInterpolation($.NSImageInterpolationHigh)
+
+  const shadow = $.NSShadow.alloc.init
+  shadow.setShadowOffset($.NSMakeSize(0, -8))
+  shadow.setShadowBlurRadius(30)
+  shadow.setShadowColor($.NSColor.colorWithWhiteAlpha(0, 0.22))
+  shadow.set
+  // A layer, so the shadow falls from the clipped icon and not from the clip.
+  $.CGContextBeginTransparencyLayer(context.CGContext, null)
+  shape.addClip
+  image.drawInRectFromRectOperationFraction(
+    $.NSMakeRect(min, min, body, body), $.NSZeroRect, $.NSCompositingOperationSourceOver, 1
+  )
+  $.CGContextEndTransparencyLayer(context.CGContext)
+  context.flushGraphics
+
+  const png = bitmap.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.dictionary)
+  if (!png.writeToFileAtomically(output, true)) throw new Error("Cannot write " + output)
+}
+`

package/src/packager.mjs

@@ -0,0 +1,5 @@
+// Runs `@electron/packager` with the options `buildDesktopApp` passes as JSON. Started under
+// Electron's own Node, not Bun: see `packageApp`.
+import { packager } from "@electron/packager"
+
+await packager(JSON.parse(process.argv[2]))

package/src/run.ts

@@ -0,0 +1,11 @@
+/** Runs a command to completion, quietly unless it fails: then it throws `failure` and its errors. */
+export async function run(command: readonly string[], failure: string): Promise<void> {
+  const child = Bun.spawn([...command], {
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: 120_000,
+  })
+  const [exitCode, errors] = await Promise.all([child.exited, new Response(child.stderr).text()])
+  if (exitCode !== 0) {
+    throw new Error(`[SixbDesktop] ${failure}${errors.trim() ? `\n${errors.trim()}` : ""}`)
+  }
+}