@zogien/native-sdk 0.11.0-fork.2 → 0.11.0-fork.4

package/src/tooling/windows_installer.zig

@@ -0,0 +1,245 @@
+//! `native package --target windows --installer`: turns the Windows
+//! artifact directory into a per-user setup program.
+//!
+//! The artifact directory becomes the install image: it gains
+//! `native-install.json` (the install configuration) and
+//! `native-launcher.exe` (the launcher the setup program copies to the
+//! stable `<root>\<name>.exe`). setup.exe is the launcher program with the
+//! configuration and a ZIP of the image appended, followed by a trailer
+//! carrying their SHA-256 (src/windows_install/payload.zig).
+
+const std = @import("std");
+const manifest_tool = @import("manifest.zig");
+const package = @import("package.zig");
+const zip_writer = @import("zip_writer.zig");
+const install_config = @import("windows_install_config");
+const setup_payload = @import("windows_install_payload");
+
+pub const launcher_file_in_image = "native-launcher.exe";
+pub const launcher_x86_64 = @embedFile("windows_launcher_x86_64");
+pub const launcher_aarch64 = @embedFile("windows_launcher_aarch64");
+
+pub const Arch = enum {
+    x86_64,
+    aarch64,
+
+    pub fn launcher(self: Arch) []const u8 {
+        return switch (self) {
+            .x86_64 => launcher_x86_64,
+            .aarch64 => launcher_aarch64,
+        };
+    }
+};
+
+pub const Options = struct {
+    /// The Windows artifact directory `native package` just staged.
+    artifact_dir: []const u8,
+    metadata: manifest_tool.Metadata,
+    /// The app executable's file name in `bin\`.
+    executable: []const u8,
+    arch: Arch,
+    output_path: []const u8,
+};
+
+/// The setup program's file name: `<name>-<version>-windows-<arch>-setup.exe`.
+pub fn setupFileName(allocator: std.mem.Allocator, metadata: manifest_tool.Metadata, arch: Arch) ![]const u8 {
+    return std.fmt.allocPrint(allocator, "{s}-{s}-windows-{s}-setup.exe", .{ metadata.name, metadata.version, @tagName(arch) });
+}
+
+/// The update archive's file name: `<name>-<version>-windows-<arch>-update.zip`.
+pub fn updateArchiveFileName(allocator: std.mem.Allocator, metadata: manifest_tool.Metadata, arch: Arch) ![]const u8 {
+    return std.fmt.allocPrint(allocator, "{s}-{s}-windows-{s}-update.zip", .{ metadata.name, metadata.version, @tagName(arch) });
+}
+
+pub fn createSetup(allocator: std.mem.Allocator, io: std.Io, options: Options) !void {
+    var arena_state = std.heap.ArenaAllocator.init(allocator);
+    defer arena_state.deinit();
+    const arena = arena_state.allocator();
+    const image = try buildImage(arena, io, options);
+
+    const program = options.arch.launcher();
+    const trailer = setup_payload.encode(.{
+        .config_offset = program.len,
+        .config_size = image.config.len,
+        .zip_offset = program.len + image.config.len,
+        .zip_size = image.zip.len,
+        .sha256 = setup_payload.digest(image.config, image.zip),
+    });
+    try writeAtomically(io, options.output_path, &.{ program, image.config, image.zip, &trailer });
+}
+
+/// The ZIP of the install image the updater downloads: the same image a
+/// setup program carries, signed into a feed by `native update sign`.
+pub fn createUpdateArchive(allocator: std.mem.Allocator, io: std.Io, options: Options) !void {
+    var arena_state = std.heap.ArenaAllocator.init(allocator);
+    defer arena_state.deinit();
+    const image = try buildImage(arena_state.allocator(), io, options);
+    try writeAtomically(io, options.output_path, &.{image.zip});
+}
+
+const Image = struct {
+    config: []const u8,
+    zip: []const u8,
+};
+
+/// Adds the install configuration and launcher to the artifact directory
+/// and zips it, without the portable registration script.
+fn buildImage(arena: std.mem.Allocator, io: std.Io, options: Options) !Image {
+    var artifact = try std.Io.Dir.cwd().openDir(io, options.artifact_dir, .{});
+    defer artifact.close(io);
+    const has_icon = if (artifact.access(io, "app-icon.ico", .{})) |_| true else |_| false;
+    const config = try installConfig(arena, options.metadata, options.executable, has_icon);
+    try install_config.validate(config);
+
+    var config_writer: std.Io.Writer.Allocating = .init(arena);
+    try install_config.write(config, &config_writer.writer);
+    const config_bytes = config_writer.written();
+    try artifact.writeFile(io, .{ .sub_path = install_config.file_name, .data = config_bytes });
+    try artifact.writeFile(io, .{ .sub_path = launcher_file_in_image, .data = options.arch.launcher() });
+
+    const collected = try zip_writer.collectDirectory(arena, io, options.artifact_dir);
+    var image: std.ArrayList(zip_writer.Entry) = .empty;
+    for (collected) |entry| {
+        // The portable artifact's registration script points at bin\; an
+        // installed app registers through the setup program instead.
+        if (std.mem.startsWith(u8, entry.name, "install/")) continue;
+        try image.append(arena, entry);
+    }
+    var zip: std.Io.Writer.Allocating = .init(arena);
+    try zip_writer.write(arena, &zip.writer, image.items);
+    return .{ .config = config_bytes, .zip = zip.written() };
+}
+
+fn writeAtomically(io: std.Io, path: []const u8, parts: []const []const u8) !void {
+    if (std.fs.path.dirname(path)) |parent| try std.Io.Dir.cwd().createDirPath(io, parent);
+    var atomic = try std.Io.Dir.cwd().createFileAtomic(io, path, .{ .make_path = true, .replace = true });
+    defer atomic.deinit(io);
+    var buffer: [64 * 1024]u8 = undefined;
+    var writer = atomic.file.writer(io, &buffer);
+    for (parts) |part| try writer.interface.writeAll(part);
+    try writer.interface.flush();
+    try atomic.replace(io);
+}
+
+/// The install configuration for an app: its identity, executable and
+/// icon, and the HKCU\Software\Classes values its file associations and
+/// URL schemes need, pointing at the installed launcher so a pending
+/// version switch also applies when a document or link opens the app.
+pub fn installConfig(allocator: std.mem.Allocator, metadata: manifest_tool.Metadata, executable: []const u8, has_icon: bool) !install_config.InstallConfig {
+    var registry: std.ArrayList(install_config.RegistryValue) = .empty;
+    var cleanup: std.ArrayList(install_config.RegistryCleanup) = .empty;
+    const open_command = "\"" ++ install_config.launcher_placeholder ++ "\" \"%1\"";
+    const document_icon = if (has_icon) install_config.install_placeholder ++ "\\app\\app-icon.ico" else install_config.launcher_placeholder;
+
+    for (metadata.file_associations) |association| {
+        const prog_id = try package.windowsProgId(allocator, metadata, association);
+        const prog_key = try std.fmt.allocPrint(allocator, "Software\\Classes\\{s}", .{prog_id});
+        for (association.extensions) |extension| {
+            const extension_key = try std.fmt.allocPrint(allocator, "Software\\Classes\\.{s}", .{package.trimExtensionDot(extension)});
+            try registry.append(allocator, .{ .key = extension_key, .value = prog_id });
+            try cleanup.append(allocator, .{ .key = extension_key, .name = "", .if_value = prog_id });
+        }
+        try registry.append(allocator, .{ .key = prog_key, .value = association.name });
+        try registry.append(allocator, .{ .key = prog_key, .name = "FriendlyTypeName", .value = association.name });
+        try registry.append(allocator, .{ .key = try std.fmt.allocPrint(allocator, "{s}\\DefaultIcon", .{prog_key}), .value = document_icon });
+        try registry.append(allocator, .{ .key = try std.fmt.allocPrint(allocator, "{s}\\shell\\open\\command", .{prog_key}), .value = open_command });
+        try cleanup.append(allocator, .{ .key = prog_key });
+    }
+    for (metadata.url_schemes) |url_scheme| {
+        const scheme_key = try std.fmt.allocPrint(allocator, "Software\\Classes\\{s}", .{url_scheme.scheme});
+        try registry.append(allocator, .{ .key = scheme_key, .value = try std.fmt.allocPrint(allocator, "URL:{s}", .{url_scheme.scheme}) });
+        try registry.append(allocator, .{ .key = scheme_key, .name = "URL Protocol", .value = "" });
+        try registry.append(allocator, .{ .key = try std.fmt.allocPrint(allocator, "{s}\\shell\\open\\command", .{scheme_key}), .value = open_command });
+        try cleanup.append(allocator, .{ .key = scheme_key });
+    }
+
+    return .{
+        .bundle_id = metadata.id,
+        .name = metadata.name,
+        .display_name = metadata.displayName(),
+        .version = metadata.version,
+        .executable = executable,
+        .icon = if (has_icon) "app-icon.ico" else "",
+        .registry = try registry.toOwnedSlice(allocator),
+        .registry_cleanup = try cleanup.toOwnedSlice(allocator),
+    };
+}
+
+test "an app's associations and URL schemes register through the installed launcher" {
+    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena_state.deinit();
+    const arena = arena_state.allocator();
+    const associations = [_]manifest_tool.FileAssociationMetadata{.{ .name = "Markdown", .extensions = &.{"md"} }};
+    const schemes = [_]manifest_tool.UrlSchemeMetadata{.{ .scheme = "acme-notes" }};
+    const metadata: manifest_tool.Metadata = .{
+        .id = "dev.example.notes",
+        .name = "notes",
+        .display_name = "Acme Notes",
+        .version = "1.2.3",
+        .file_associations = &associations,
+        .url_schemes = &schemes,
+    };
+    const config = try installConfig(arena, metadata, "notes.exe", true);
+    try install_config.validate(config);
+    try std.testing.expectEqualStrings("Acme Notes", config.display_name);
+    try std.testing.expectEqualStrings("app-icon.ico", config.icon);
+    try std.testing.expectEqualStrings("Software\\Classes\\.md", config.registry[0].key);
+    try std.testing.expectEqualStrings("dev.example.notes.Markdown", config.registry[0].value);
+    try std.testing.expectEqualStrings("\"{launcher}\" \"%1\"", config.registry[4].value);
+    try std.testing.expectEqualStrings("Software\\Classes\\acme-notes\\shell\\open\\command", config.registry[7].key);
+    // The extension's default value goes only while it still names this
+    // app; the app's own ProgID and scheme keys go whole.
+    try std.testing.expectEqualStrings("dev.example.notes.Markdown", config.registry_cleanup[0].if_value.?);
+    try std.testing.expect(config.registry_cleanup[1].name == null);
+}
+
+test "setup.exe carries the launcher, its configuration and the install image" {
+    const allocator = std.testing.allocator;
+    const io = std.testing.io;
+    var cwd = std.Io.Dir.cwd();
+    const root = ".zig-cache/test-windows-setup";
+    try cwd.deleteTree(io, root);
+    defer cwd.deleteTree(io, root) catch {};
+    try cwd.createDirPath(io, root ++ "/artifact/bin");
+    try cwd.createDirPath(io, root ++ "/artifact/install");
+    try cwd.writeFile(io, .{ .sub_path = root ++ "/artifact/bin/notes.exe", .data = "app" });
+    try cwd.writeFile(io, .{ .sub_path = root ++ "/artifact/install/register-file-types.ps1", .data = "script" });
+    try cwd.writeFile(io, .{ .sub_path = root ++ "/artifact/app-icon.ico", .data = "icon" });
+
+    const metadata: manifest_tool.Metadata = .{ .id = "dev.example.notes", .name = "notes", .version = "1.2.3" };
+    try createSetup(allocator, io, .{ .artifact_dir = root ++ "/artifact", .metadata = metadata, .executable = "notes.exe", .arch = .x86_64, .output_path = root ++ "/notes-setup.exe" });
+
+    const setup = try cwd.readFileAlloc(io, root ++ "/notes-setup.exe", allocator, .unlimited);
+    defer allocator.free(setup);
+    try std.testing.expect(std.mem.startsWith(u8, setup, launcher_x86_64));
+    const trailer = setup_payload.find(setup[setup.len - setup_payload.trailer_len ..], setup.len).?;
+    try std.testing.expectEqual(@as(u64, launcher_x86_64.len), trailer.config_offset);
+    const config_bytes = setup[@intCast(trailer.config_offset)..][0..@intCast(trailer.config_size)];
+    const zip_bytes = setup[@intCast(trailer.zip_offset)..][0..@intCast(trailer.zip_size)];
+    try std.testing.expectEqualSlices(u8, &trailer.sha256, &setup_payload.digest(config_bytes, zip_bytes));
+    var parsed = try install_config.parse(allocator, config_bytes);
+    defer parsed.deinit();
+    try std.testing.expectEqualStrings("notes", parsed.value.name);
+
+    try cwd.writeFile(io, .{ .sub_path = root ++ "/image.zip", .data = zip_bytes });
+    try cwd.createDirPath(io, root ++ "/extracted");
+    var extracted = try cwd.openDir(io, root ++ "/extracted", .{});
+    defer extracted.close(io);
+    var archive = try cwd.openFile(io, root ++ "/image.zip", .{});
+    defer archive.close(io);
+    var buffer: [4096]u8 = undefined;
+    var reader = archive.reader(io, &buffer);
+    try std.zip.extract(extracted, &reader, .{});
+    const launcher = try extracted.readFileAlloc(io, launcher_file_in_image, allocator, .unlimited);
+    defer allocator.free(launcher);
+    try std.testing.expectEqualSlices(u8, launcher_x86_64, launcher);
+    try std.testing.expectError(error.FileNotFound, extracted.access(io, "install/register-file-types.ps1", .{}));
+    try extracted.access(io, "bin/notes.exe", .{});
+    try extracted.access(io, install_config.file_name, .{});
+
+    // The updater downloads the very image the setup program carries.
+    try createUpdateArchive(allocator, io, .{ .artifact_dir = root ++ "/artifact", .metadata = metadata, .executable = "notes.exe", .arch = .x86_64, .output_path = root ++ "/notes-update.zip" });
+    const update_archive = try cwd.readFileAlloc(io, root ++ "/notes-update.zip", allocator, .unlimited);
+    defer allocator.free(update_archive);
+    try std.testing.expectEqualSlices(u8, zip_bytes, update_archive);
+}

package/src/tooling/zip_writer.zig

@@ -0,0 +1,211 @@
+//! A small ZIP writer for install images and update archives: deflate
+//! (or store, when deflate does not help), UTF-8 names with forward
+//! slashes, and a fixed timestamp so the same tree always produces the
+//! same bytes. No ZIP64: an archive stays below 4 GiB and 65535 entries.
+//! `std.zip` reads what this writes.
+
+const std = @import("std");
+const flate = std.compress.flate;
+
+pub const Entry = struct {
+    /// Forward-slash path inside the archive, without a leading slash.
+    name: []const u8,
+    data: []const u8,
+};
+
+pub const Error = error{ ZipTooLarge, InvalidZipEntryName } || std.mem.Allocator.Error || std.Io.Writer.Error;
+
+const dos_time: u16 = 0;
+/// 1980-01-01, the earliest date a ZIP timestamp can hold.
+const dos_date: u16 = (0 << 9) | (1 << 5) | 1;
+const version: u16 = 20;
+/// General purpose flag bit 11: names are UTF-8.
+const utf8_flag: u16 = 0x0800;
+
+const Written = struct {
+    name: []const u8,
+    method: std.zip.CompressionMethod,
+    crc32: u32,
+    compressed_size: u32,
+    uncompressed_size: u32,
+    offset: u32,
+};
+
+pub fn write(allocator: std.mem.Allocator, out: *std.Io.Writer, entries: []const Entry) Error!void {
+    if (entries.len > std.math.maxInt(u16)) return error.ZipTooLarge;
+    const written = try allocator.alloc(Written, entries.len);
+    defer allocator.free(written);
+    const window = try allocator.alloc(u8, flate.max_window_len);
+    defer allocator.free(window);
+
+    var offset: u64 = 0;
+    for (entries, 0..) |entry, index| {
+        try validateName(entry.name);
+        if (entry.data.len > std.math.maxInt(u32)) return error.ZipTooLarge;
+        var compressed: std.Io.Writer.Allocating = try .initCapacity(allocator, @max(64, entry.data.len / 2));
+        defer compressed.deinit();
+        var compressor = try flate.Compress.init(&compressed.writer, window, .raw, .default);
+        try compressor.writer.writeAll(entry.data);
+        try compressor.finish();
+        const deflated = compressed.written().len < entry.data.len;
+        const body = if (deflated) compressed.written() else entry.data;
+        if (offset > std.math.maxInt(u32)) return error.ZipTooLarge;
+        written[index] = .{
+            .name = entry.name,
+            .method = if (deflated) .deflate else .store,
+            .crc32 = std.hash.Crc32.hash(entry.data),
+            .compressed_size = @intCast(body.len),
+            .uncompressed_size = @intCast(entry.data.len),
+            .offset = @intCast(offset),
+        };
+        const record = written[index];
+        try out.writeAll(&std.zip.local_file_header_sig);
+        try out.writeInt(u16, version, .little);
+        try out.writeInt(u16, utf8_flag, .little);
+        try out.writeInt(u16, @intFromEnum(record.method), .little);
+        try out.writeInt(u16, dos_time, .little);
+        try out.writeInt(u16, dos_date, .little);
+        try out.writeInt(u32, record.crc32, .little);
+        try out.writeInt(u32, record.compressed_size, .little);
+        try out.writeInt(u32, record.uncompressed_size, .little);
+        try out.writeInt(u16, @intCast(entry.name.len), .little);
+        try out.writeInt(u16, 0, .little);
+        try out.writeAll(entry.name);
+        try out.writeAll(body);
+        offset += 30 + entry.name.len + body.len;
+    }
+
+    if (offset > std.math.maxInt(u32)) return error.ZipTooLarge;
+    const central_offset: u32 = @intCast(offset);
+    var central_size: u64 = 0;
+    for (written) |record| {
+        try out.writeAll(&std.zip.central_file_header_sig);
+        try out.writeInt(u16, version, .little);
+        try out.writeInt(u16, version, .little);
+        try out.writeInt(u16, utf8_flag, .little);
+        try out.writeInt(u16, @intFromEnum(record.method), .little);
+        try out.writeInt(u16, dos_time, .little);
+        try out.writeInt(u16, dos_date, .little);
+        try out.writeInt(u32, record.crc32, .little);
+        try out.writeInt(u32, record.compressed_size, .little);
+        try out.writeInt(u32, record.uncompressed_size, .little);
+        try out.writeInt(u16, @intCast(record.name.len), .little);
+        try out.writeInt(u16, 0, .little);
+        try out.writeInt(u16, 0, .little);
+        try out.writeInt(u16, 0, .little);
+        try out.writeInt(u16, 0, .little);
+        try out.writeInt(u32, 0, .little);
+        try out.writeInt(u32, record.offset, .little);
+        try out.writeAll(record.name);
+        central_size += 46 + record.name.len;
+    }
+    if (central_size > std.math.maxInt(u32)) return error.ZipTooLarge;
+    try out.writeAll(&std.zip.end_record_sig);
+    try out.writeInt(u16, 0, .little);
+    try out.writeInt(u16, 0, .little);
+    try out.writeInt(u16, @intCast(entries.len), .little);
+    try out.writeInt(u16, @intCast(entries.len), .little);
+    try out.writeInt(u32, @intCast(central_size), .little);
+    try out.writeInt(u32, central_offset, .little);
+    try out.writeInt(u16, 0, .little);
+}
+
+/// Collects every file under `root` (a directory path relative to the
+/// working directory) as archive entries named by their forward-slash
+/// path below it, sorted so the archive is reproducible. The caller frees
+/// the names and data with `freeEntries`.
+pub fn collectDirectory(allocator: std.mem.Allocator, io: std.Io, root: []const u8) ![]Entry {
+    var dir = try std.Io.Dir.cwd().openDir(io, root, .{ .iterate = true });
+    defer dir.close(io);
+    var walker = try dir.walk(allocator);
+    defer walker.deinit();
+    var entries: std.ArrayList(Entry) = .empty;
+    errdefer freeEntries(allocator, entries.items);
+    errdefer entries.deinit(allocator);
+    while (try walker.next(io)) |item| {
+        if (item.kind != .file) continue;
+        const name = try allocator.dupe(u8, item.path);
+        errdefer allocator.free(name);
+        std.mem.replaceScalar(u8, name, '\\', '/');
+        const data = try dir.readFileAlloc(io, item.path, allocator, .unlimited);
+        errdefer allocator.free(data);
+        try entries.append(allocator, .{ .name = name, .data = data });
+    }
+    std.mem.sort(Entry, entries.items, {}, lessThan);
+    return entries.toOwnedSlice(allocator);
+}
+
+pub fn freeEntries(allocator: std.mem.Allocator, entries: []const Entry) void {
+    for (entries) |entry| {
+        allocator.free(entry.name);
+        allocator.free(entry.data);
+    }
+}
+
+fn lessThan(_: void, a: Entry, b: Entry) bool {
+    return std.mem.lessThan(u8, a.name, b.name);
+}
+
+fn validateName(name: []const u8) error{InvalidZipEntryName}!void {
+    if (name.len == 0 or name.len > std.math.maxInt(u16)) return error.InvalidZipEntryName;
+    if (name[0] == '/' or std.mem.indexOfScalar(u8, name, '\\') != null) return error.InvalidZipEntryName;
+    var parts = std.mem.splitScalar(u8, name, '/');
+    while (parts.next()) |part| {
+        if (part.len == 0 or std.mem.eql(u8, part, ".") or std.mem.eql(u8, part, "..")) return error.InvalidZipEntryName;
+    }
+}
+
+test "an archive std.zip extracts back to the same tree" {
+    const allocator = std.testing.allocator;
+    const io = std.testing.io;
+    var tmp = std.testing.tmpDir(.{ .iterate = true });
+    defer tmp.cleanup();
+
+    const repetitive = "native " ** 4096;
+    const entries = [_]Entry{
+        .{ .name = "bin/demo.exe", .data = "MZ-not-really" },
+        .{ .name = "resources/assets/text.txt", .data = repetitive },
+        .{ .name = "native-install.json", .data = "{}" },
+    };
+    var archive: std.Io.Writer.Allocating = .init(allocator);
+    defer archive.deinit();
+    try write(allocator, &archive.writer, &entries);
+    try tmp.dir.writeFile(io, .{ .sub_path = "image.zip", .data = archive.written() });
+    try std.testing.expect(archive.written().len < repetitive.len);
+
+    try tmp.dir.createDirPath(io, "out");
+    var out = try tmp.dir.openDir(io, "out", .{});
+    defer out.close(io);
+    var file = try tmp.dir.openFile(io, "image.zip", .{});
+    defer file.close(io);
+    var buffer: [4096]u8 = undefined;
+    var reader = file.reader(io, &buffer);
+    try std.zip.extract(out, &reader, .{});
+
+    for (entries) |entry| {
+        const bytes = try out.readFileAlloc(io, entry.name, allocator, .unlimited);
+        defer allocator.free(bytes);
+        try std.testing.expectEqualStrings(entry.data, bytes);
+    }
+}
+
+test "the same entries always produce the same bytes" {
+    const allocator = std.testing.allocator;
+    const entries = [_]Entry{.{ .name = "a.txt", .data = "abc" }};
+    var first: std.Io.Writer.Allocating = .init(allocator);
+    defer first.deinit();
+    var second: std.Io.Writer.Allocating = .init(allocator);
+    defer second.deinit();
+    try write(allocator, &first.writer, &entries);
+    try write(allocator, &second.writer, &entries);
+    try std.testing.expectEqualSlices(u8, first.written(), second.written());
+}
+
+test "entry names stay inside the archive" {
+    const allocator = std.testing.allocator;
+    var archive: std.Io.Writer.Allocating = .init(allocator);
+    defer archive.deinit();
+    for ([_][]const u8{ "", "/abs.txt", "../up.txt", "a/../b.txt", "a\\b.txt", "a//b.txt" }) |name| {
+        try std.testing.expectError(error.InvalidZipEntryName, write(allocator, &archive.writer, &.{.{ .name = name, .data = "x" }}));
+    }
+}