@sixb/desktop 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sixb contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,82 @@
-# Temporary Holding Version
+# `@sixb/desktop`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Ships a Sixb project's app as a desktop app, built with [Electron](https://www.electronjs.org).
+Install it in a project, and the `sixb` CLI does the rest:
+
+```bash
+bun add -d @sixb/desktop
+bun sixb dev --desktop      # the dev server, and the app in a desktop window
+bun sixb desktop build      # the deployed app, packaged for this machine
+```
+
+See [Desktop App](https://docs.sixb.ai/apps/desktop) for what the desktop app takes from the app,
+signing, and distribution. The rest of this file is how it works.
+
+## How it works
+
+The CLI does not depend on this package, because it brings Electron. It loads the project's copy
+and calls its two exports, `openDesktopApp` and `buildDesktopApp`, with the app's URL and the API's
+origin. Both generate the same Electron app first:
+
+```
+<app>/app.webmanifest ─▶ name, icon        (src/identity.ts)
+        │
+        ▼
+.sixb/desktop/app/        rewritten on every call (src/generate.ts)
+  main.js                 the main process, compiled from src/shell/main.ts
+  shell.json              name, app URL, API origin
+  index.html              the page shown while the app loads
+  preload.js, icon.png
+        │
+        ├─ openDesktopApp   electron .sixb/desktop/app
+        └─ buildDesktopApp  @electron/packager ─▶ .sixb/desktop/dist/
+```
+
+The window loads the app from where it is served; `app/` is not compiled into the binary. The
+page runs sandboxed, with no Node and no channel into the main process, and the window stays on the
+app and API origins (`src/shell/window.ts`): any other link opens in the user's browser.
+
+### macOS builds
+
+- **Icon.** `src/mac-icon.ts` redraws the icon on Apple's grid, a rounded square of 824 pixels with
+  continuous corners in a canvas of 1024, over a soft shadow. Both were measured against Apple's
+  Notes icon. An icon drawn to its edges otherwise stands larger than every icon beside it. It runs
+  AppKit through `osascript`, and `sips` and `iconutil` turn the result into `.icns`.
+- **Signature.** Packaging breaks the ad-hoc signature Electron ships with, and macOS calls a
+  downloaded app with a broken signature damaged, with no way to open it. An unsigned build is
+  re-signed ad hoc, so users can allow it. With `APPLE_API_KEY`, `APPLE_API_KEY_ID` and
+  `APPLE_API_ISSUER`, the packager signs with the keychain's Developer ID certificate and notarizes
+  instead.
+- **Packager.** `@electron/packager` fails under Bun whenever it verifies a download, so
+  `src/packager.mjs` runs it under Electron's own binary as Node.
+
+### Signing in
+
+A window like this cannot finish a sign-in on its own: a magic link opens in the user's browser,
+not in the window, and identity providers refuse embedded browsers. So the shell sends the window
+to `GET /auth/sign-in/device` instead of the sign-in page, and opens the approval page in the
+system browser:
+
+```
+window                         API                          system browser
+  │  app redirects to /auth/sign-in                              │
+  │  shell loads /auth/sign-in/device ─▶ creates an authorization│
+  │◀─ "Continue in your browser", cookie holds its secret        │
+  │  shell opens /auth/device?user_code=… ──────────────────────▶│ signs in if needed,
+  │                                      ◀── Authorize ──────────│ approves
+  │  page reloads ─▶ approved: session cookie, back to the app   │
+```
+
+The session is an ordinary browser session, kept in the window's persistent cookie store, so later
+launches open straight into the app. `src/shell/navigation.ts` holds those two decisions as a pure
+function; `src/shell/main.ts` wires them to the window.
+
+### Title bar
+
+On macOS the window has no title bar: the app draws to the top edge and the window controls float
+over it. Two things a title bar did then come from the shell (`src/shell/window.ts`):
+
+- A 36px strip across the top is the handle the window is dragged by. Buttons, links and form
+  controls under it still take their clicks; the space between them moves the window.
+- `<html data-sixb-desktop="inset">` and `--sixb-desktop-controls-height` let an app make room for
+  the controls. The sidebar of the default `AppShell` is moved down for it already.

package/dist/generate.d.ts

@@ -0,0 +1,30 @@
+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;
+}
+/** Where a project's desktop app is generated (`app`) and packaged (`dist`). */
+export declare function desktopDir(projectRoot: string, part: "app" | "dist"): string;
+/**
+ * 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 declare function writeDesktopApp(options: DesktopAppOptions): Promise<GeneratedApp>;
+/** The page the window shows while the app loads, and when it cannot reach the app. */
+export declare function renderShellPage(template: string, page: {
+    readonly name: string;
+    readonly appUrl: string;
+    readonly icon: boolean;
+}): string;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,iBAAiB;IAChC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,qGAAqG;IACrG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAKD,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAE5E;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CA4CvF;AAED,uFAAuF;AACvF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC/E,MAAM,CAYR"}

package/dist/identity.d.ts

@@ -0,0 +1,22 @@
+/** 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 declare function readAppIdentity(appUrl: string): Promise<AppIdentity>;
+/**
+ * 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 declare function bundleIdentifier(appUrl: string): string;
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;CACjC;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAa1E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAOvD"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { type DesktopAppOptions } from "./generate";
+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;
+}
+/** Opens the app in a desktop window. `sixb dev --desktop` calls this. */
+export declare function openDesktopApp(options: DesktopAppOptions): Promise<DesktopWindow>;
+/** Packages the app for this machine's platform. `sixb desktop build` calls this. */
+export declare function buildDesktopApp(options: DesktopAppOptions): Promise<DesktopBuild>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAA+B,MAAM,YAAY,CAAA;AAIhF,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IAChC,KAAK,IAAI,IAAI,CAAA;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAMD,0EAA0E;AAC1E,wBAAsB,cAAc,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CAsBvF;AAED,qFAAqF;AACrF,wBAAsB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAiCvF"}

package/dist/index.js

@@ -0,0 +1,383 @@
+// @bun
+// src/index.ts
+import { mkdir as mkdir2, readdir, rm as rm2 } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/generate.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { fileURLToPath } from "url";
+
+// src/identity.ts
+async function readAppIdentity(appUrl) {
+  const manifestUrl = new URL("/app.webmanifest", appUrl);
+  const manifest = await (await fetchFromApp(manifestUrl)).json();
+  const { name, icons } = typeof manifest === "object" && manifest !== null ? manifest : {};
+  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
+  };
+}
+function bundleIdentifier(appUrl) {
+  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(".");
+}
+function desktopIcon(icons, manifestUrl) {
+  let best = null;
+  for (const icon of Array.isArray(icons) ? icons : []) {
+    if (typeof icon !== "object" || icon === null)
+      continue;
+    const { src, sizes, type, purpose } = icon;
+    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];
+    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) {
+  let 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;
+}
+
+// src/run.ts
+async function run(command, failure) {
+  const child = Bun.spawn([...command], {
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: 120000
+  });
+  const [exitCode, errors] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+  if (exitCode !== 0) {
+    throw new Error(`[SixbDesktop] ${failure}${errors.trim() ? `
+${errors.trim()}` : ""}`);
+  }
+}
+
+// src/mac-icon.ts
+async function drawMacIcon(png, out) {
+  await run(["osascript", "-l", "JavaScript", "-e", MAC_ICON_SCRIPT, png, out], "Could not draw the macOS icon.");
+}
+var 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)
+}
+`;
+
+// src/shell/window.ts
+var CONTROLS_HEIGHT_PX = 36;
+var HIDDEN_TITLE_BAR_CSS = [
+  `#sixb-desktop-drag{position:fixed;top:0;left:0;right:0;height:${CONTROLS_HEIGHT_PX}px;`,
+  "z-index:2147483647;pointer-events:none;-webkit-app-region:drag}",
+  `${[
+    "a",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "summary",
+    "label",
+    "[role=button]",
+    "[role=link]",
+    "[role=tab]",
+    "[role=menuitem]",
+    "[role=switch]",
+    "[role=checkbox]",
+    "[role=combobox]",
+    "[contenteditable]",
+    "[tabindex]:not([tabindex='-1'])"
+  ].join(",")}{-webkit-app-region:no-drag}`,
+  `[data-slot="sidebar-inner"]{padding-top:calc(${CONTROLS_HEIGHT_PX}px - 0.5rem)}`
+].join("");
+var HIDDEN_TITLE_BAR_PRELOAD = `(() => {
+  const mark = () => {
+    const root = document.documentElement
+    if (!root) return false
+    root.dataset.sixbDesktop = "inset"
+    root.style.setProperty("--sixb-desktop-controls-height", "${CONTROLS_HEIGHT_PX}px")
+    return true
+  }
+  if (!mark()) {
+    const observer = new MutationObserver(() => {
+      if (mark()) observer.disconnect()
+    })
+    observer.observe(document, { childList: true })
+  }
+
+  const addHandle = () => {
+    if (!document.body || document.getElementById("sixb-desktop-drag")) return
+    const handle = document.createElement("div")
+    handle.id = "sixb-desktop-drag"
+    handle.setAttribute("aria-hidden", "true")
+    // First in the body, not last: the draggable area is built in document order, so a control
+    // is only cut out of it if it comes after the handle.
+    document.body.prepend(handle)
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", addHandle, { once: true })
+  } else {
+    addHandle()
+  }
+})()
+`;
+
+// src/generate.ts
+var SHELL_SOURCE_DIR = fileURLToPath(new URL("../src/shell", import.meta.url));
+function desktopDir(projectRoot, part) {
+  return join(projectRoot, ".sixb", "desktop", part);
+}
+async function writeDesktopApp(options) {
+  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 = {
+    name: identity.name,
+    appUrl: new URL(options.appUrl).href,
+    apiOrigin: new URL(options.apiOrigin).origin
+  };
+  const manifest = {
+    name: "sixb-desktop-app",
+    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)}
+`),
+    writeFile(join(dir, "shell.json"), `${JSON.stringify(config, null, 2)}
+`),
+    writeFile(join(dir, "preload.js"), HIDDEN_TITLE_BAR_PRELOAD),
+    writeFile(join(dir, "index.html"), renderShellPage(template, { ...config, icon: !!icon }))
+  ]);
+  await run([
+    process.execPath,
+    "build",
+    join(SHELL_SOURCE_DIR, "main.ts"),
+    "--target=node",
+    "--format=cjs",
+    "--external=electron",
+    `--outfile=${join(dir, "main.js")}`
+  ], "Could not compile the desktop shell.");
+  return { dir, name: identity.name, version, icon };
+}
+function renderShellPage(template, page) {
+  const initial = Array.from(page.name.trim())[0]?.toUpperCase() ?? "";
+  const markup = {
+    name: escapeHtml(page.name),
+    host: escapeHtml(new URL(page.appUrl).host),
+    appUrl: escapeHtml(page.appUrl),
+    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) => markup[key] ?? "");
+}
+async function writeIcon(dir, png) {
+  const icon = join(dir, "icon.png");
+  if (process.platform !== "darwin") {
+    await writeFile(icon, png);
+    return icon;
+  }
+  const source = join(dir, "..", "icon-source.png");
+  await writeFile(source, png);
+  await drawMacIcon(source, icon);
+  return icon;
+}
+async function readProjectVersion(projectRoot) {
+  try {
+    const manifest = JSON.parse(await readFile(join(projectRoot, "package.json"), "utf-8"));
+    const version = manifest?.version;
+    return typeof version === "string" ? version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+
+// src/index.ts
+var packageRequire = createRequire(import.meta.url);
+var PACKAGER_SCRIPT = fileURLToPath2(new URL("../src/packager.mjs", import.meta.url));
+async function openDesktopApp(options) {
+  const app = await writeDesktopApp(options);
+  const log = join2(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();
+    }
+  };
+}
+async function buildDesktopApp(options) {
+  const app = await writeDesktopApp(options);
+  const out = desktopDir(options.projectRoot, "dist");
+  await rm2(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").version,
+    ...mac && app.icon ? { icon: await macIcon(app.icon) } : {},
+    ...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 = join2(packaged, name);
+  if (!notarize) {
+    await run(["codesign", "--force", "--deep", "--sign", "-", bundle], "Could not sign the app.");
+  }
+  const zip = `${packaged}.zip`;
+  await run(["ditto", "-c", "-k", "--keepParent", bundle, zip], "Could not zip the app.");
+  return { path: zip, signed: notarize !== null };
+}
+function appleNotarization() {
+  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
+  };
+}
+async function macIcon(png) {
+  const desktop = dirname(dirname(png));
+  const iconset = join2(desktop, "icon.iconset");
+  await rm2(iconset, { recursive: true, force: true });
+  await mkdir2(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", join2(iconset, name)], "Could not scale the icon.")));
+  const icns = join2(desktop, "icon.icns");
+  await run(["iconutil", "-c", "icns", iconset, "-o", icns], "Could not convert the icon.");
+  return icns;
+}
+async function packageApp(options) {
+  const packager = Bun.spawn([electronBinary(), PACKAGER_SCRIPT, JSON.stringify({ ...options, quiet: true })], {
+    stdio: ["ignore", "inherit", "inherit"],
+    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 join2(options.out, written);
+}
+function electronBinary() {
+  try {
+    return packageRequire("electron");
+  } 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.`);
+  }
+}
+export {
+  buildDesktopApp,
+  openDesktopApp
+};
+
+//# debugId=30FED6904B68AC4164756E2164756E21