akanjs 3.0.0 → 3.0.2-rc.0

package/vendor/@akanjs/native/packages/cli/src/lib/dsStore.ts

@@ -0,0 +1,191 @@
+
+
+export type DsStoreValue =
+  | { type: "long"; value: number }
+  | { type: "bool"; value: boolean }
+  | { type: "type"; value: string }
+  | { type: "blob"; value: Uint8Array }
+  | { type: "ustr"; value: string };
+
+export interface DsStoreRecord {
+  /** The file the record is about, "." for the folder itself. */
+  name: string;
+  /** Four letters: Iloc (icon location), bwsp (window), icvp (icon view), vSrn, icvl … */
+  code: string;
+  value: DsStoreValue;
+}
+
+const PAGE_SIZE = 4096;
+
+class Writer {
+  #chunks: Uint8Array[] = [];
+  length = 0;
+  bytes(data: Uint8Array): this {
+    this.#chunks.push(data);
+    this.length += data.length;
+    return this;
+  }
+  u8(value: number): this {
+    return this.bytes(Uint8Array.of(value));
+  }
+  u32(value: number): this {
+    const data = new Uint8Array(4);
+    new DataView(data.buffer).setUint32(0, value >>> 0);
+    return this.bytes(data);
+  }
+  fourCC(code: string): this {
+    if (!/^[\x20-\x7e]{4}$/.test(code)) throw new Error(`not a four-letter code: ${JSON.stringify(code)}`);
+    return this.bytes(new TextEncoder().encode(code));
+  }
+  utf16(text: string): this {
+    const data = new Uint8Array(text.length * 2);
+    const view = new DataView(data.buffer);
+    for (let i = 0; i < text.length; i++) view.setUint16(i * 2, text.charCodeAt(i));
+    return this.bytes(data);
+  }
+  toBytes(): Uint8Array {
+    const out = new Uint8Array(this.length);
+    let at = 0;
+    for (const chunk of this.#chunks) {
+      out.set(chunk, at);
+      at += chunk.length;
+    }
+    return out;
+  }
+}
+
+/** Finder compares names as HFS+ does, case-insensitively; a window's few ASCII names need nothing more. */
+function compareRecords(a: DsStoreRecord, b: DsStoreRecord): number {
+  const left = a.name.toLowerCase();
+  const right = b.name.toLowerCase();
+  if (left !== right) return left < right ? -1 : 1;
+  return a.code < b.code ? -1 : a.code > b.code ? 1 : 0;
+}
+
+function writeRecord(out: Writer, { name, code, value }: DsStoreRecord): void {
+  out.u32(name.length).utf16(name).fourCC(code).fourCC(value.type);
+  if (value.type === "long") out.u32(value.value);
+  else if (value.type === "bool") out.u8(value.value ? 1 : 0);
+  else if (value.type === "type") out.fourCC(value.value);
+  else if (value.type === "blob") out.u32(value.value.length).bytes(value.value);
+  else out.u32(value.value.length).utf16(value.value);
+}
+
+/** The buddy allocator's free lists after the given allocations, each address a power-of-two block. */
+class Buddy {
+  readonly free: number[][] = Array.from({ length: 32 }, () => []);
+  constructor() {
+    this.free[31]?.push(0);
+  }
+  allocate(size: number): { offset: number; width: number } {
+    const width = Math.max(5, Math.ceil(Math.log2(size)));
+    let w = width;
+    while (w < 32 && !this.free[w]?.length) w++;
+    const offset = this.free[w]?.shift();
+    if (offset === undefined) throw new Error(`no free block of ${size} bytes`);
+    while (w > width) {
+      w--;
+      this.free[w]?.push(offset + 2 ** w);
+      this.free[w]?.sort((a, b) => a - b);
+    }
+    return { offset, width };
+  }
+}
+
+export function writeDsStore(records: DsStoreRecord[]): Uint8Array {
+  const sorted = [...records].sort(compareRecords);
+  const leaf = new Writer().u32(0).u32(sorted.length);
+  for (const record of sorted) writeRecord(leaf, record);
+  if (leaf.length > PAGE_SIZE)
+    throw new Error(
+      `${sorted.length} .DS_Store records need ${leaf.length} bytes, more than one ${PAGE_SIZE}-byte node`,
+    );
+
+  const buddy = new Buddy();
+  buddy.allocate(32); 
+  const root = buddy.allocate(2048);
+  const header = buddy.allocate(32);
+  const node = buddy.allocate(PAGE_SIZE);
+  const address = ({ offset, width }: { offset: number; width: number }) => offset | width;
+
+  const dsdb = new Writer().u32(2).u32(0).u32(sorted.length).u32(1).u32(PAGE_SIZE);
+  const blocks = [root, header, node];
+  const allocator = new Writer().u32(blocks.length).u32(0);
+  for (const block of blocks) allocator.u32(address(block));
+  for (let i = blocks.length; i < 256; i++) allocator.u32(0);
+  allocator.u32(1).u8(4).fourCC("DSDB").u32(1);
+  for (const list of buddy.free) {
+    allocator.u32(list.length);
+    for (const offset of list) allocator.u32(offset);
+  }
+  if (allocator.length > 2 ** root.width) throw new Error(".DS_Store allocator block overflows");
+
+  const end = Math.max(...blocks.map(({ offset, width }) => offset + 2 ** width));
+  const file = new Uint8Array(4 + end);
+  const view = new DataView(file.buffer);
+  view.setUint32(0, 1);
+  file.set(new TextEncoder().encode("Bud1"), 4);
+  view.setUint32(8, root.offset);
+  view.setUint32(12, 2 ** root.width);
+  view.setUint32(16, root.offset);
+  file.set(allocator.toBytes(), 4 + root.offset);
+  file.set(dsdb.toBytes(), 4 + header.offset);
+  file.set(leaf.toBytes(), 4 + node.offset);
+  return file;
+}
+
+/** Reads back what writeDsStore wrote (one leaf): the tests' check, and a way to look at a .DS_Store. */
+export function readDsStore(file: Uint8Array): DsStoreRecord[] {
+  const view = new DataView(file.buffer, file.byteOffset, file.byteLength);
+  if (view.getUint32(0) !== 1 || new TextDecoder().decode(file.subarray(4, 8)) !== "Bud1")
+    throw new Error("not a .DS_Store");
+  const rootOffset = view.getUint32(8);
+  const blockAt = (index: number) => {
+    const raw = view.getUint32(4 + rootOffset + 8 + index * 4);
+    return 4 + (raw & ~0x1f);
+  };
+  const dsdb = blockAt(1);
+  const leafIndex = view.getUint32(dsdb);
+  let at = blockAt(leafIndex);
+  if (view.getUint32(at) !== 0) throw new Error("only a single-leaf .DS_Store is read");
+  const count = view.getUint32(at + 4);
+  at += 8;
+  const fourCC = () => {
+    const code = new TextDecoder().decode(file.subarray(at, at + 4));
+    at += 4;
+    return code;
+  };
+  const utf16 = (units: number) => {
+    let text = "";
+    for (let i = 0; i < units; i++) text += String.fromCharCode(view.getUint16(at + i * 2));
+    at += units * 2;
+    return text;
+  };
+  const records: DsStoreRecord[] = [];
+  for (let i = 0; i < count; i++) {
+    const nameLength = view.getUint32(at);
+    at += 4;
+    const name = utf16(nameLength);
+    const code = fourCC();
+    const type = fourCC();
+    let value: DsStoreValue;
+    if (type === "long") {
+      value = { type, value: view.getUint32(at) };
+      at += 4;
+    } else if (type === "bool") {
+      value = { type, value: file[at] === 1 };
+      at += 1;
+    } else if (type === "type") value = { type, value: fourCC() };
+    else if (type === "blob") {
+      const length = view.getUint32(at);
+      value = { type, value: file.slice(at + 4, at + 4 + length) };
+      at += 4 + length;
+    } else if (type === "ustr") {
+      const length = view.getUint32(at);
+      at += 4;
+      value = { type, value: utf16(length) };
+    } else throw new Error(`unsupported .DS_Store type ${type}`);
+    records.push({ name, code, value });
+  }
+  return records;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/exec.ts

@@ -62,14 +62,24 @@ export async function exec(cmd: string[], options: ExecOptions = {}): Promise<Ex
   const signal = signals.getStore();
   
   const stream = options.inherit && isTerminal() ? "inherit" : "pipe";
+
+  const group = !!signal && process.platform !== "win32";
   const proc = Bun.spawn(cmd, {
     cwd: options.cwd,
     env: options.env ? { ...process.env, ...options.env } : process.env,
     stdin: "ignore",
     stdout: stream,
     stderr: stream,
-    ...(signal ? { signal } : {}),
+    ...(group ? { detached: true } : signal ? { signal } : {}),
   });
+  const killGroup = () => {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {
+    }
+  };
+  if (group && signal) signal.addEventListener("abort", killGroup, { once: true });
+  void proc.exited.finally(() => signal?.removeEventListener("abort", killGroup));
   let stdout = "";
   let stderr = "";
   if (options.inherit && stream === "pipe") {

package/vendor/@akanjs/native/packages/cli/src/lib/macAlias.ts

@@ -0,0 +1,101 @@
+
+
+export interface AliasTarget {
+  /** The HFS+ volume name (the disk image's label). */
+  volumeName: string;
+  /**
+   * The volume header's createDate as it stands, in HFS seconds. HFS+ writes it on the local clock of whatever formatted
+   * the volume (TN1150), unlike every other date, so it is read off the image rather than computed here.
+   */
+  volumeCreated: number;
+  /** Where the volume mounts: /Volumes/<name>. */
+  volumePath: string;
+  kind: "file" | "folder";
+  name: string;
+  cnid: number;
+  created: Date;
+  parentName: string;
+  parentCnid: number;
+  /** The CNIDs of the folders above the target, nearest first, the volume's root left out. */
+  cnidPath: number[];
+  /** From the volume's root, starting with "/". */
+  posixPath: string;
+}
+
+/** Seconds since 1904-01-01 UTC, the HFS epoch. */
+export function hfsTime(date: Date): number {
+  return Math.max(0, Math.floor(date.getTime() / 1000) + 2_082_844_800) >>> 0;
+}
+
+const EJECTABLE_DISK = 5;
+
+/** A Carbon name: ':' is the path separator there, so a name spells it '/'. */
+function pascal(text: string, size: number): Uint8Array {
+  const bytes = new TextEncoder().encode(text.replaceAll(":", "/")).subarray(0, size - 1);
+  const out = new Uint8Array(size);
+  out[0] = bytes.length;
+  out.set(bytes, 1);
+  return out;
+}
+
+function utf16WithLength(text: string): Uint8Array {
+  const out = new Uint8Array(2 + text.length * 2);
+  const view = new DataView(out.buffer);
+  view.setUint16(0, text.length);
+  for (let i = 0; i < text.length; i++) view.setUint16(2 + i * 2, text.charCodeAt(i));
+  return out;
+}
+
+export function aliasRecord(target: AliasTarget): Uint8Array {
+  const fixed = new Uint8Array(150);
+  const view = new DataView(fixed.buffer);
+  view.setUint16(6, 2);
+  view.setUint16(8, target.kind === "folder" ? 1 : 0);
+  fixed.set(pascal(target.volumeName, 28), 10);
+
+  view.setUint32(38, target.volumeCreated);
+  fixed.set(new TextEncoder().encode("H+"), 42);
+  view.setUint16(44, EJECTABLE_DISK);
+  view.setUint32(46, target.parentCnid);
+  fixed.set(pascal(target.name, 64), 50);
+  view.setUint32(114, target.cnid);
+  view.setUint32(118, hfsTime(target.created));
+  view.setInt16(130, -1);
+  view.setInt16(132, -1);
+
+  const encoder = new TextEncoder();
+  const cnids = new Uint8Array(target.cnidPath.length * 4);
+  for (const [idx, cnid] of target.cnidPath.entries()) new DataView(cnids.buffer).setUint32(idx * 4, cnid);
+  const carbonPath = [target.volumeName, ...target.posixPath.split("/").filter(Boolean)]
+    .map((part) => part.replaceAll(":", "/"))
+    .join(":");
+  const extras: [number, Uint8Array][] = [
+    [0, encoder.encode(target.parentName.replaceAll(":", "/"))],
+    [1, cnids],
+    [2, encoder.encode(carbonPath)],
+    [14, utf16WithLength(target.name)],
+    [15, utf16WithLength(target.volumeName)],
+    [18, encoder.encode(target.posixPath)],
+    [19, encoder.encode(target.volumePath)],
+  ];
+  const parts: Uint8Array[] = [fixed];
+  for (const [tag, data] of extras) {
+    const head = new Uint8Array(4);
+    new DataView(head.buffer).setInt16(0, tag);
+    new DataView(head.buffer).setUint16(2, data.length);
+    parts.push(head, data, ...(data.length % 2 ? [new Uint8Array(1)] : []));
+  }
+  const end = new Uint8Array(4);
+  new DataView(end.buffer).setInt16(0, -1);
+  parts.push(end);
+
+  const length = parts.reduce((sum, part) => sum + part.length, 0);
+  const record = new Uint8Array(length);
+  let at = 0;
+  for (const part of parts) {
+    record.set(part, at);
+    at += part.length;
+  }
+  new DataView(record.buffer).setUint16(4, length);
+  return record;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/macossigning.ts

@@ -1,7 +1,7 @@
 
 
 import { randomBytes } from "node:crypto";
-import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { exec, execOrThrow } from "./exec.ts";
@@ -283,33 +283,6 @@ export async function zipForNotary(appPath: string, zip: string): Promise<void>
 }
 
 /** A compressed disk image of the app beside a link to /Applications, the window people drag it into. */
-export async function buildDmg(appPath: string, dmgPath: string, volumeName: string, workDir: string): Promise<void> {
-  const staging = join(workDir, "dmg");
-  rmSync(staging, { recursive: true, force: true });
-  mkdirSync(staging, { recursive: true });
-  await execOrThrow(["ditto", appPath, join(staging, basename(appPath))], { echo: false });
-  symlinkSync("/Applications", join(staging, "Applications"));
-  rmSync(dmgPath, { force: true });
-  await execOrThrow(
-    [
-      "hdiutil",
-      "create",
-      "-volname",
-      volumeName,
-      "-srcfolder",
-      staging,
-      "-ov",
-      "-fs",
-      "HFS+",
-      "-format",
-      "UDZO",
-      dmgPath,
-    ],
-    { echo: false },
-  );
-  rmSync(staging, { recursive: true, force: true });
-}
-
 /** What Gatekeeper says of a notarized app or disk image, as a downloaded copy would be judged. */
 export async function assessGatekeeper(file: string, type: "execute" | "open"): Promise<void> {
   const args =

package/vendor/@akanjs/native/packages/cli/src/lib/project.ts

@@ -8,6 +8,7 @@ import { manifestPermissionProblems, type PermissionSet, resolveAcl } from "./ac
 import { unknownConfigKeys } from "./configkeys.ts";
 import { validateCsp, validateExternalSchemes } from "./csp.ts";
 import { type DesktopServerConfig, validateDesktopServer } from "./desktop-server.ts";
+import { type ResolvedDmg, validateDmg } from "./dmg.ts";
 import { type EnvConfig, validateEnvConfig } from "./env.ts";
 import { CliError } from "./log.ts";
 import { type PermissionsConfig, validatePermissions } from "./permissions.ts";
@@ -18,7 +19,8 @@ import { type UpdatesConfig, validateUpdates } from "./updates.ts";
 
 const CONFIG_FILES = ["akan-native.config.ts", "akan-native.config.js", "akan-native.config.mjs"];
 
-export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates"> {
+export interface ResolvedConfig
+  extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates" | "desktop"> {
   app: Required<AkanNativeConfig["app"]>;
   web: Required<Pick<AkanNativeConfig["web"], "dir" | "base">> & { build?: string; devEntry?: string };
   plugins: string[];
@@ -35,6 +37,7 @@ export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash"
     server?: DesktopServerConfig;
     /** Absolute. */
     bin?: string;
+    dmg: ResolvedDmg;
   };
   updates: UpdatesConfig | null;
   /** Absolute image path. */
@@ -212,6 +215,7 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
   if (bin !== undefined && !(binDir && existsSync(binDir) && statSync(binDir).isDirectory()))
     problems.push(`desktop.bin must be a folder (got ${JSON.stringify(bin)})`);
   const desktopServer = validateDesktopServer(raw.desktop, appDir, problems);
+  const dmg = validateDmg(raw.desktop?.dmg, appDir, problems);
   if (raw.keyboard?.resize !== undefined && raw.keyboard.resize !== "resize" && raw.keyboard.resize !== "none") {
     problems.push(`keyboard.resize must be "resize" or "none" (got ${JSON.stringify(raw.keyboard.resize)})`);
   }
@@ -281,6 +285,7 @@ export function projectFromConfig(raw: AkanNativeConfig, appDir: string, options
       },
       ...(desktopServer ? { server: desktopServer } : {}),
       ...(binDir ? { bin: binDir } : {}),
+      dmg,
     },
     updates,
     icon: icon ? { ...icon, image: resolve(appDir, icon.image) } : null,

package/vendor/@akanjs/native/packages/cli/src/platforms/linux-appimage.ts

@@ -11,15 +11,20 @@ import type { BuildContext } from "../lib/prepare.ts";
 import { ensureInstalled, TOOLCHAIN } from "../lib/toolchains.ts";
 import { targetArch } from "./desktop.ts";
 
-/** The launcher entry (freedesktop Desktop Entry): what a menu shows and which link schemes open the app. */
-export function desktopEntry(input: { name: string; fileName: string; schemes: string[] }): string {
+/**
+ * The launcher entry (freedesktop Desktop Entry): what a menu shows and which link schemes open the app. Named and
+ * matched by the app id, the window's program name (native/desktop lib.rs): AppImageLauncher and appimaged rename the
+ * file they install, so StartupWMClass is what still ties the window to it.
+ */
+export function desktopEntry(input: { id: string; name: string; fileName: string; schemes: string[] }): string {
   const escape = (value: string) => value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
   return [
     "[Desktop Entry]",
     "Type=Application",
     `Name=${escape(input.name)}`,
     `Exec=${input.fileName} %u`,
-    `Icon=${input.fileName}`,
+    `Icon=${input.id}`,
+    `StartupWMClass=${input.id}`,
     "Terminal=false",
     "Categories=Utility;",
     ...(input.schemes.length ? [`MimeType=${input.schemes.map((s) => `x-scheme-handler/${s};`).join("")}`] : []),
@@ -59,13 +64,18 @@ export async function buildAppImage(ctx: BuildContext, folder: string): Promise<
   writeFileSync(join(appDir, "AppRun"), appRun(config.app.fileName));
   chmodSync(join(appDir, "AppRun"), 0o755);
   writeFileSync(
-    join(appDir, `${config.app.fileName}.desktop`),
-    desktopEntry({ name: config.app.name, fileName: config.app.fileName, schemes: config.deepLinks.schemes }),
+    join(appDir, `${config.app.id}.desktop`),
+    desktopEntry({
+      id: config.app.id,
+      name: config.app.name,
+      fileName: config.app.fileName,
+      schemes: config.deepLinks.schemes,
+    }),
   );
   const art = iconArt(config);
   if (art) {
-    writeFileSync(join(appDir, `${config.app.fileName}.png`), encodePng(resize(art.master, 256, 256)));
-    symlinkSync(`${config.app.fileName}.png`, join(appDir, ".DirIcon"));
+    writeFileSync(join(appDir, `${config.app.id}.png`), encodePng(resize(art.master, 256, 256)));
+    symlinkSync(`${config.app.id}.png`, join(appDir, ".DirIcon"));
   }
 
   log.step("installer: AppImage");

package/vendor/@akanjs/native/packages/cli/src/platforms/linux.ts

@@ -4,8 +4,10 @@ import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ParsedArgs } from "../lib/args.ts";
 import { iconArt, windowIcon } from "../lib/icons.ts";
+import { resize } from "../lib/image.ts";
 import type { Launched, LaunchOptions } from "../lib/launch.ts";
 import { dim, log } from "../lib/log.ts";
+import { encodePng } from "../lib/png.ts";
 import type { BuildContext } from "../lib/prepare.ts";
 import {
   buildNativeLibrary,
@@ -39,7 +41,10 @@ export async function buildLinux(ctx: BuildContext): Promise<string> {
   const resources = resourcesOf("linux", dir);
   writeDesktopResources(ctx, resources, "linux");
   const art = iconArt(config);
-  if (art) writeFileSync(join(resources, "icon.rgba"), windowIcon(art.master));
+  if (art) {
+    writeFileSync(join(resources, "icon.rgba"), windowIcon(art.master));
+    writeFileSync(join(resources, "icon.png"), encodePng(resize(art.master, 256, 256)));
+  }
   if (ctx.linux?.appImage) ctx.artifacts.push({ kind: "installer", path: await buildAppImage(ctx, dir) });
   const size = await folderSize(dir);
   if (size) log.info(dim(`size ${size}`));

package/vendor/@akanjs/native/packages/cli/src/platforms/macos.ts

@@ -14,6 +14,7 @@ import {
 } from "node:fs";
 import { basename, join } from "node:path";
 import type { ParsedArgs } from "../lib/args.ts";
+import { buildDmg } from "../lib/dmg.ts";
 import { execOrThrow } from "../lib/exec.ts";
 import { icns, iconArt, macosIconImage } from "../lib/icons.ts";
 import type { Launched, LaunchOptions } from "../lib/launch.ts";
@@ -21,7 +22,6 @@ import { dim, log } from "../lib/log.ts";
 import {
   appEntitlements,
   assessGatekeeper,
-  buildDmg,
   codesign,
   notarize,
   type ResolvedMacosIdentity,
@@ -144,7 +144,10 @@ export async function buildMacos(ctx: BuildContext): Promise<string> {
       if (ctx.macos?.dmg) {
         const dmg = join(outDir, `${config.app.fileName}-${config.app.version}-${ctx.arch ?? hostArch()}.dmg`);
         log.step(`dmg: ${basename(dmg)}`);
-        await buildDmg(appPath, dmg, config.app.name, join(outDir, "gen"));
+        await buildDmg(appPath, dmg, config.app.name, join(outDir, "gen"), {
+          layout: config.desktop.dmg,
+          volumeIcon: join(resources, "AppIcon.icns"),
+        });
         
         if (identity.sign !== "-") await codesign(identity, dmg, { hardened: false, timestamp: team });
         if (notarization) {

package/vendor/@akanjs/native/packages/desktop/src/deeplinks.ts

@@ -25,12 +25,19 @@ export function desktopExec(exe: string): string {
   return `"${exe.replace(/[\\"`$]/g, (c) => `\\${c}`)}" %u`;
 }
 
-export function desktopEntry(name: string, exe: string, schemes: readonly string[]): string {
+export function desktopEntry(
+  name: string,
+  exe: string,
+  schemes: readonly string[],
+  { id, icon = false }: { id?: string; icon?: boolean } = {},
+): string {
   return [
     "[Desktop Entry]",
     "Type=Application",
     `Name=${name.replace(/[\r\n]/g, " ")}`,
     `Exec=${desktopExec(exe)}`,
+    ...(id && icon ? [`Icon=${id}`] : []),
+    ...(id ? [`StartupWMClass=${id}`] : []),
     "Terminal=false",
     
     "NoDisplay=true",
@@ -69,17 +76,28 @@ function writeIfChanged(path: string, text: string): boolean {
   return true;
 }
 
+/** Copies the app's icon into the user's hicolor theme as <app id>.png; false without one. */
+function installIcon(dataHome: string, id: string, icon: string | undefined): boolean {
+  if (!icon || !existsSync(icon)) return false;
+  const target = join(dataHome, "icons", "hicolor", "256x256", "apps", `${id}.png`);
+  const bytes = readFileSync(icon);
+  if (existsSync(target) && readFileSync(target).equals(bytes)) return true;
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, bytes);
+  return true;
+}
+
 async function registerLinux(
   app: { id: string; name: string },
   exe: string,
   schemes: readonly string[],
-  env: Env,
-  home: string,
-  runner: Runner,
+  { env, home, runner, icon }: { env: Env; home: string; runner: Runner; icon?: string },
 ): Promise<void> {
   const file = `${app.id}.desktop`;
-  const applications = join(xdg(env.XDG_DATA_HOME, join(home, ".local", "share")), "applications");
-  const entryChanged = writeIfChanged(join(applications, file), desktopEntry(app.name, exe, schemes));
+  const dataHome = xdg(env.XDG_DATA_HOME, join(home, ".local", "share"));
+  const applications = join(dataHome, "applications");
+  const entry = desktopEntry(app.name, exe, schemes, { id: app.id, icon: installIcon(dataHome, app.id, icon) });
+  const entryChanged = writeIfChanged(join(applications, file), entry);
   const listPath = join(xdg(env.XDG_CONFIG_HOME, join(home, ".config")), "mimeapps.list");
   const list = existsSync(listPath) ? readFileSync(listPath, "utf8") : "";
   writeIfChanged(listPath, withDefaults(list, file, schemes));
@@ -128,16 +146,21 @@ async function registerWindows(
   }
 }
 
-/** Makes this executable the current user's handler of the app's schemes (Windows, Linux). */
+/**
+ * Makes this executable the current user's handler of the app's schemes (Windows, Linux). `icon`: a 256 px PNG the
+ * Linux entry shows (resources/icon.png).
+ */
 export async function registerDeepLinks(
   app: { id: string; name: string },
   schemes: readonly string[],
-  options: { exe?: string; platform?: NodeJS.Platform; env?: Env; home?: string; run?: Runner } = {},
+  options: { exe?: string; platform?: NodeJS.Platform; env?: Env; home?: string; run?: Runner; icon?: string } = {},
 ): Promise<void> {
   const platform = options.platform ?? process.platform;
   if (!schemes.length || (platform !== "win32" && platform !== "linux")) return;
-  const exe = options.exe ?? process.execPath;
+  const env = options.env ?? process.env;
+  
+  const exe = options.exe ?? (env.APPIMAGE || process.execPath);
   const runner = options.run ?? run;
   if (platform === "win32") await registerWindows(app, exe, schemes, runner);
-  else await registerLinux(app, exe, schemes, options.env ?? process.env, options.home ?? homedir(), runner);
+  else await registerLinux(app, exe, schemes, { env, home: options.home ?? homedir(), runner, icon: options.icon });
 }

package/vendor/@akanjs/native/packages/desktop/src/host.ts

@@ -447,7 +447,7 @@ export function startHost(plugins: DesktopPlugin[]): void {
       if (typeof launch.exit === "number") return;
       
       openLinks(process.argv.slice(2));
-      registerDeepLinks(boot.app, deepLinkSchemes).catch((error) =>
+      registerDeepLinks(boot.app, deepLinkSchemes, { icon: join(paths.resources, "icon.png") }).catch((error) =>
         console.warn("[akan-native] cannot register the deep link schemes", error),
       );
     })