@akanjs/devkit 3.1.1-rc.1 → 3.1.1-rc.11

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/mobile/updateUploader.test.ts

@@ -83,6 +83,40 @@ describe("UpdateUploader", () => {
     );
   });
 
+  test("uploads a desktop release's envelope, with the v1 pair only when the pair is that release", async () => {
+    const manifest = { kind: "app", bundle: "1.3.0-3000", archive: { url: `app/${sha("c")}.tar.gz` }, patches: [] };
+    await inUpdatesDir(
+      {
+        [`macos-arm64/app/${sha("c")}.tar.gz`]: "tar",
+        "macos-arm64/main/app.json": envelope(manifest),
+        "macos-arm64/main.json": JSON.stringify({ ...manifest, bundle: "1.2.0-2000" }),
+        "macos-arm64/main.json.sig": "sig",
+        "macos-arm64/beta/app.json": envelope({ ...manifest, bundle: "1.4.0-4000" }),
+        "macos-arm64/beta.json": JSON.stringify({ ...manifest, bundle: "1.4.0-4000" }),
+        "macos-arm64/beta.json.sig": "sig",
+      },
+      async (updatesDir) => {
+        const dir = path.join(updatesDir, "macos-arm64");
+        const upload = async (channel: string, bundle: string) => {
+          const { bucket, writes } = fakeBucket();
+          await new UpdateUploader(bucket, "").upload(updatesDir, { dir, channel, bundle });
+          return writes.map(({ key }) => key);
+        };
+
+        expect(await upload("main", "1.3.0-3000")).toEqual([
+          `macos-arm64/app/${sha("c")}.tar.gz`,
+          "macos-arm64/main/app.json",
+        ]);
+        expect(await upload("beta", "1.4.0-4000")).toEqual([
+          `macos-arm64/app/${sha("c")}.tar.gz`,
+          "macos-arm64/beta.json.sig",
+          "macos-arm64/beta.json",
+          "macos-arm64/beta/app.json",
+        ]);
+      },
+    );
+  });
+
   test("uploads a phone release's own files and envelope, never pack records or another manifest beside them", async () => {
     await inUpdatesDir(
       {

package/mobile/updateUploader.ts

@@ -51,12 +51,8 @@ export class UpdateUploader {
   //* APIs, which a later publish from another machine may have replaced.
   static async releaseFiles(updatesDir: string, { dir, channel, bundle }: PublishedUpdate): Promise<string[]> {
     const keyOf = (file: unknown) => UpdateUploader.#keyOf(updatesDir, dir, file);
-    const desktop = await UpdateUploader.#read<UpdateManifest>(path.join(dir, `${channel}.json`));
-    if (desktop?.bundle === bundle) {
-      const archive = desktop.archive?.url;
-      const patches = UpdateUploader.#field(desktop.patches, "url");
-      return [archive, ...patches, `${channel}.json.sig`, `${channel}.json`].map(keyOf);
-    }
+    const v1 = await UpdateUploader.#read<UpdateManifest>(path.join(dir, `${channel}.json`));
+    const pair = v1?.bundle === bundle ? [`${channel}.json.sig`, `${channel}.json`] : [];
     const names = await readdir(path.join(dir, channel)).catch(() => [] as string[]);
     for (const name of names.filter((name) => name.endsWith(".json"))) {
       const envelope = await UpdateUploader.#read<UpdateEnvelope>(path.join(dir, channel, name));
@@ -65,6 +61,8 @@ export class UpdateUploader {
           ? UpdateUploader.#parse<UpdateManifest>(Buffer.from(envelope.manifest, "base64").toString("utf8"))
           : null;
       if (manifest?.bundle !== bundle) continue;
+      if (manifest.kind === "app")
+        return [...UpdateUploader.#appFiles(manifest), ...pair, `${channel}/${name}`].map(keyOf);
       const hashes = [...new Set(UpdateUploader.#field(manifest.files, "sha256"))];
       if (!hashes.every((hash): hash is string => typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash)))
         throw new Error(
@@ -72,9 +70,14 @@ export class UpdateUploader {
         );
       return [...hashes.map((hash) => `${UpdatePackFolder.filesDir}/${hash}`), `${channel}/${name}`].map(keyOf);
     }
+    if (v1 && pair.length) return [...UpdateUploader.#appFiles(v1), ...pair].map(keyOf);
     throw new Error(`${dir} holds no ${channel} manifest of release ${bundle}; nothing was uploaded.`);
   }
 
+  static #appFiles(manifest: Partial<UpdateManifest>): unknown[] {
+    return [manifest.archive?.url, ...UpdateUploader.#field(manifest.patches, "url")];
+  }
+
   static #keyOf(updatesDir: string, dir: string, file: unknown) {
     const resolved = typeof file === "string" ? path.resolve(dir, file) : "";
     const key = path.relative(updatesDir, resolved);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.1.1-rc.1",
+  "version": "3.1.1-rc.11",
   "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.1",
+    "akanjs": "3.1.1-rc.11",
     "chalk": "^6.0.1",
     "commander": "^15.0.0",
     "dayjs": "^1.11.23",

package/platformTest/LinuxDockerTarget.ts

@@ -40,6 +40,9 @@ export class LinuxDockerTarget extends PlatformTestTarget {
       "run",
       "-d",
       "--rm",
+      //? An init as PID 1 reaps orphans as a real host does; under `sleep` a killed orphan stays a zombie that still
+      //? answers kill(pid, 0).
+      "--init",
       "--name",
       container,
       "--cpus",

package/signalMutationIndex.test.ts

@@ -110,6 +110,21 @@ export class ItemEndpoint extends endpoint(srv.item, ({ query, mutation }) => ({
     expect(index.isMutation("apps/third/page/x.tsx", "approveTicket")).toBe(false);
   });
 
+  test("reads a lib page's call by its own lib's endpoint before another lib's of that name", () => {
+    const shared = fileOf(
+      "libs/shared/lib/_shared/shared.signal.ts",
+      `export class SharedEndpoint extends endpoint(srv.shared, ({ mutation }) => ({ syncFeed: mutation(Boolean, {}).exec(() => true) })) {}`,
+    );
+    const social = fileOf(
+      "libs/social/lib/_social/social.signal.ts",
+      `export class SocialEndpoint extends endpoint(srv.social, ({ query }) => ({ syncFeed: query(Boolean, {}).exec(() => true) })) {}`,
+    );
+    const index = new SignalMutationIndex([shared, social]);
+    expect(index.isMutation("libs/social/page/x.tsx", "syncFeed")).toBe(false);
+    expect(index.policyIndexOf("libs/social/page/x.tsx", "syncFeed")).toBeNull();
+    expect(index.isMutation("libs/shared/page/x.tsx", "syncFeed")).toBe(true);
+  });
+
   test("ignores signal tests and specs", () => {
     const spec = fileOf(
       "apps/demo/lib/ticket/ticket.signal.spec.ts",

package/signalMutationIndex.ts

@@ -34,7 +34,7 @@ export class SignalMutationIndex {
 
   #shapeOf(consumerFile: string, name: string) {
     const [root, owner] = consumerFile.split("/");
-    const own = root === "apps" ? this.#shapesByOwner.get(`apps/${owner}`)?.get(name) : undefined;
+    const own = this.#shapesByOwner.get(`${root}/${owner}`)?.get(name);
     if (own) return own;
     for (const [key, shapes] of this.#shapesByOwner) {
       const shape = shapes.get(name);

package/types.ts

@@ -12,6 +12,7 @@ export interface PackageJson {
   optionalDependencies?: Record<string, string>;
   trustedDependencies?: string[];
   overrides?: Record<string, string>;
+  resolutions?: Record<string, string>;
   engines?: Record<string, string>;
   exports?: Record<string, string | Record<string, string>>;
   bun?: {