@akanjs/devkit 3.1.1-rc.5 → 3.1.1-rc.7

package/mobile/nativeApp.ts

@@ -5,6 +5,7 @@ import type { AkanNativeConfig } from "akanjs/native/config";
 import type { App } from "../commandDecorators";
 import { Executor } from "../executors";
 import { type DesktopArch, DesktopBin } from "./desktopBin";
+import { DesktopRelease } from "./desktopRelease";
 import type { DesktopServerBundle } from "./desktopServerStage";
 import {
   type DesktopPlatform,
@@ -311,6 +312,22 @@ export class NativeApp {
     return path.join(this.targetRoot, "updates");
   }
 
+  //? The channel falls back as publishUpdate's does, so a push with the flags of the publish finds what it wrote.
+  async publishedRelease(platform: DesktopPlatform, { arch, channel }: { arch: DesktopArch; channel?: string | null }) {
+    this.#assertUpdates();
+    const { config } = await this.config({ platform, stageBin: false });
+    const publicKey = config.updates?.publicKeys?.[0] ?? config.updates?.publicKey;
+    if (!config.updates || !publicKey) throw new Error(`Native target '${this.target.name}' has no updates key.`);
+    const release = await DesktopRelease.read(this.updatesDir, {
+      platform,
+      arch,
+      channel: channel ?? config.updates.channel ?? "production",
+      appId: config.app.id,
+      publicKey,
+    });
+    return { release, url: config.updates.url, exeName: config.app.fileName ?? "" };
+  }
+
   /** A signed release installed apps take through the updates plugin, from a release build of this bundle. */
   async publishUpdate(
     platform: NativePlatform,

package/mobile/tarWriter.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { tempDirs } from "../testHelpers";
+import { TarWriter } from "./tarWriter";
+
+const makeDir = tempDirs("akan-tar-writer-");
+const delta = `./app/${"a".repeat(64)}-${"b".repeat(64)}.delta.gz`;
+const sha256 = (bytes: string | Uint8Array) => createHash("sha256").update(bytes).digest("hex");
+
+const write = async (file: string, entries: [string, string][], mtime = 1_761_700_000) => {
+  const tar = await TarWriter.create(file, { mtime });
+  const digests: string[] = [];
+  for (const [name, body] of entries) digests.push(await tar.add(name, new Blob([body])));
+  await tar.close();
+  return digests;
+};
+
+describe("TarWriter", () => {
+  test("a system tar reads back every file under its name, a 144-byte one too, and lists nothing else", async () => {
+    const dir = await makeDir();
+    const file = path.join(dir, "release.tar");
+    const entries: [string, string][] = [
+      ["./release.json", '{"schema":1}\n'],
+      [delta, "x".repeat(1_000)],
+    ];
+
+    const digests = await write(file, entries);
+
+    expect(digests).toEqual(entries.map(([, body]) => sha256(body)));
+    const listed = Bun.spawnSync(["tar", "-tf", file]).stdout.toString().split(/\r?\n/).filter(Boolean);
+    expect(listed).toEqual(entries.map(([name]) => name));
+    const out = path.join(dir, "out");
+    await mkdir(out);
+    expect(Bun.spawnSync(["tar", "-xf", file, "-C", out]).exitCode).toBe(0);
+    for (const [name, body] of entries) expect(await readFile(path.join(out, name), "utf8")).toBe(body);
+  });
+
+  test("writes ustar headers of mode 0644, owner 0 and the given mtime, padded to 512-byte blocks", async () => {
+    const dir = await makeDir();
+    const file = path.join(dir, "release.tar");
+
+    await write(file, [["./a.json", "{}"]], 1_761_700_000);
+
+    const bytes = await readFile(file);
+    const field = (at: number, width: number) => bytes.subarray(at, at + width).toString("latin1");
+    expect(field(0, 9)).toBe("./a.json\0");
+    expect(field(100, 8)).toBe("0000644\0");
+    expect(field(108, 16)).toBe("0000000\x000000000\0");
+    expect(Number.parseInt(field(136, 11), 8)).toBe(1_761_700_000);
+    expect(field(156, 1)).toBe("0");
+    expect(field(257, 8)).toBe("ustar\x0000");
+    expect(bytes.length).toBe(512 + 512 + 1024);
+    expect(bytes.subarray(1024).every((byte) => byte === 0)).toBe(true);
+  });
+
+  test("the same files and mtime make the same archive", async () => {
+    const dir = await makeDir();
+    const entries: [string, string][] = [
+      ["./main.json", "{}\n"],
+      [delta, "patch"],
+    ];
+
+    await write(path.join(dir, "one.tar"), entries);
+    await write(path.join(dir, "two.tar"), entries);
+
+    expect(sha256(await readFile(path.join(dir, "one.tar")))).toBe(sha256(await readFile(path.join(dir, "two.tar"))));
+  });
+
+  test("refuses a file whose length is not the one it was announced with", async () => {
+    const dir = await makeDir();
+    const tar = await TarWriter.create(path.join(dir, "release.tar"));
+    const grown = { size: 3, stream: () => new Blob(["abcdef"]).stream() } as unknown as Blob;
+
+    await expect(tar.add("./app/x.tar.gz", grown)).rejects.toThrow(
+      "./app/x.tar.gz changed while it was archived: 6 bytes, not 3.",
+    );
+    await tar.discard();
+  });
+
+  test("never overwrites an existing file", async () => {
+    const file = path.join(await makeDir(), "release.tar");
+    await Bun.write(file, "kept");
+
+    await expect(TarWriter.create(file)).rejects.toThrow();
+    expect(await readFile(file, "utf8")).toBe("kept");
+  });
+});

package/mobile/tarWriter.ts

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { type FileHandle, open } from "node:fs/promises";
+
+//* An uncompressed POSIX tar of regular files, the same bytes on every OS. A system tar also writes what the host keeps
+//* beside a file (macOS bsdtar an AppleDouble `._` entry for extended attributes), which a receiver refusing unlisted
+//* entries rejects. A name past the ustar field's 100 bytes travels in a pax `path` record before its header.
+export class TarWriter {
+  static readonly #block = 512;
+  static readonly #nameBytes = 100;
+  //? The size field holds 11 octal digits.
+  static readonly #maxSize = 8 ** 11 - 1;
+  readonly #handle: FileHandle;
+  readonly #mtime: number;
+
+  private constructor(handle: FileHandle, mtime: number) {
+    this.#handle = handle;
+    this.#mtime = mtime;
+  }
+
+  //? `mtime` (seconds) goes on every entry, so the same files make the same archive.
+  static async create(file: string, { mtime = 0 }: { mtime?: number } = {}) {
+    return new TarWriter(await open(file, "wx"), mtime);
+  }
+
+  async add(name: string, source: Blob): Promise<string> {
+    const { size } = source;
+    if (size > TarWriter.#maxSize) throw new Error(`${name} is ${size} bytes, more than a tar entry holds.`);
+    if (Buffer.byteLength(name) > TarWriter.#nameBytes) {
+      const pax = Buffer.from(TarWriter.#paxRecord("path", name));
+      await this.#write(
+        TarWriter.#header(`./PaxHeaders/${name.split("/").at(-1) ?? ""}`, pax.length, this.#mtime, "x"),
+      );
+      await this.#write(pax);
+      await this.#pad(pax.length);
+    }
+    await this.#write(TarWriter.#header(name, size, this.#mtime, "0"));
+    const hasher = createHash("sha256");
+    let written = 0;
+    for await (const chunk of source.stream()) {
+      hasher.update(chunk);
+      await this.#write(chunk);
+      written += chunk.length;
+    }
+    if (written !== size) throw new Error(`${name} changed while it was archived: ${written} bytes, not ${size}.`);
+    await this.#pad(size);
+    return hasher.digest("hex");
+  }
+
+  async close() {
+    await this.#write(new Uint8Array(TarWriter.#block * 2));
+    await this.#handle.close();
+  }
+
+  async discard() {
+    await this.#handle.close().catch(() => undefined);
+  }
+
+  async #write(bytes: Uint8Array) {
+    for (let at = 0; at < bytes.length; ) at += (await this.#handle.write(bytes, at)).bytesWritten;
+  }
+
+  async #pad(size: number) {
+    const rest = size % TarWriter.#block;
+    if (rest) await this.#write(new Uint8Array(TarWriter.#block - rest));
+  }
+
+  //? A record's length counts its own digits: `<length> <key>=<value>\n`.
+  static #paxRecord(key: string, value: string) {
+    const body = Buffer.byteLength(` ${key}=${value}\n`);
+    let length = body + 1;
+    while (body + String(length).length !== length) length = body + String(length).length;
+    return `${length} ${key}=${value}\n`;
+  }
+
+  static #header(name: string, size: number, mtime: number, type: "0" | "x") {
+    const header = Buffer.alloc(TarWriter.#block);
+    header.write(name, 0, TarWriter.#nameBytes, "utf8");
+    const octal = (value: number, at: number, width: number) =>
+      header.write(`${value.toString(8).padStart(width - 1, "0")}\0`, at, width, "latin1");
+    octal(0o644, 100, 8);
+    octal(0, 108, 8);
+    octal(0, 116, 8);
+    octal(size, 124, 12);
+    octal(mtime, 136, 12);
+    header.write("        ", 148, 8, "latin1");
+    header.write(type, 156, 1, "latin1");
+    header.write("ustar\0", 257, 6, "latin1");
+    header.write("00", 263, 2, "latin1");
+    const checksum = header.reduce((sum, byte) => sum + byte, 0);
+    header.write(`${checksum.toString(8).padStart(6, "0")}\0 `, 148, 8, "latin1");
+    return header;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.1.1-rc.5",
+  "version": "3.1.1-rc.7",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -48,7 +48,7 @@
     "@earendil-works/pi-tui": "1.3.0",
     "@inquirer/prompts": "^8.7.3",
     "@tailwindcss/node": "^4.3.3",
-    "akanjs": "3.1.1-rc.5",
+    "akanjs": "3.1.1-rc.7",
     "chalk": "^6.0.1",
     "commander": "^15.0.0",
     "dayjs": "^1.11.23",