fix: port Zig FFI to Zig 0.15 API

hyperpolymath · claude · hyperpolymath · commit 77d992783ed5 · 2026-03-16T16:32:10.000Z
- Migrate build.zig to createModule/root_module pattern
- Rename reserved keyword 'error' to 'err' in extern declarations
- Replace callconv(.C) with callconv(.c)
- Replace std.io.getStdOut with std.fs.File.stdout
- Replace std.time.sleep with std.Thread.sleep
- Replace posix.empty_sigset with posix.sigemptyset()
- Make HealthZone enum u8 for atomic compatibility
- Remove static lib target (PIC issue)
- Use native target instead of explicit musl

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/interface/ffi/build.zig b/src/interface/ffi/build.zig
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
 //
-// Session Sentinel FFI — Zig Build Configuration
+// Session Sentinel FFI — Zig Build Configuration (Zig 0.15+)
 //
 // Builds the native system tray binary (session-sentinel-tray) which provides
 // KDE/Wayland StatusNotifierItem integration via DBus. Links against libdbus-1
@@ -14,104 +14,90 @@
 //   zig build test         — run unit tests (no DBus required)
 //   zig build test-integration — run integration tests (DBus session bus required)
 //   zig build install      — install to ~/.local/bin/
-//   zig build docs         — generate documentation
 //
 // Dependencies:
 //   - libdbus-1 (system library, typically from dbus-devel / libdbus-1-dev)
-//   - sd-daemon (optional, for systemd watchdog integration)
+//   - libsystemd (for sd_notify watchdog integration)
 
 const std = @import("std");
 
 /// Build configuration for session-sentinel-tray.
 ///
 /// This produces a single native executable that implements the DBus
 /// StatusNotifierItem protocol for KDE/Wayland system tray integration.
-/// The binary communicates with the ReScript monitoring core via DBus IPC.
+/// The binary communicates with the monitoring core via DBus IPC.
 pub fn build(b: *std.Build) void {
     // -------------------------------------------------------------------------
     // Target and optimisation
     // -------------------------------------------------------------------------
 
-    const target = b.standardTargetOptions(.{
-        .default_target = .{
-            .cpu_arch = .x86_64,
-            .os_tag = .linux,
-        },
-    });
+    const target = b.standardTargetOptions(.{});
 
     const optimize = b.standardOptimizeOption(.{});
 
     // -------------------------------------------------------------------------
-    // Main executable: session-sentinel-tray
+    // Shared module for main source (reused across exe, libs, tests)
     // -------------------------------------------------------------------------
 
-    const exe = b.addExecutable(.{
-        .name = "session-sentinel-tray",
+    const main_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
+        .pic = true,
     });
+    main_mod.linkSystemLibrary("dbus-1", .{});
+    main_mod.linkSystemLibrary("libsystemd", .{});
 
-    // Link libdbus-1 (system library for DBus communication)
-    exe.linkSystemLibrary("dbus-1");
-
-    // Link libsystemd for sd_notify watchdog integration (optional at runtime)
-    exe.linkSystemLibrary("systemd");
+    // -------------------------------------------------------------------------
+    // Main executable: session-sentinel-tray
+    // -------------------------------------------------------------------------
 
-    // Link libc (required for libdbus-1 interop)
-    exe.linkLibC();
+    const exe = b.addExecutable(.{
+        .name = "session-sentinel-tray",
+        .root_module = main_mod,
+    });
 
-    // Install the executable
     b.installArtifact(exe);
 
     // -------------------------------------------------------------------------
     // Shared library (for FFI consumers — Idris2, ReScript via Deno FFI)
     // -------------------------------------------------------------------------
 
-    const lib = b.addSharedLibrary(.{
-        .name = "session_sentinel_tray",
+    const lib_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
+    lib_mod.linkSystemLibrary("dbus-1", .{});
+    lib_mod.linkSystemLibrary("libsystemd", .{});
 
-    lib.version = .{ .major = 0, .minor = 1, .patch = 0 };
-    lib.linkSystemLibrary("dbus-1");
-    lib.linkSystemLibrary("systemd");
-    lib.linkLibC();
-
-    b.installArtifact(lib);
-
-    // -------------------------------------------------------------------------
-    // Static library
-    // -------------------------------------------------------------------------
-
-    const lib_static = b.addStaticLibrary(.{
+    const lib = b.addLibrary(.{
+        .linkage = .dynamic,
         .name = "session_sentinel_tray",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = lib_mod,
+        .version = .{ .major = 0, .minor = 1, .patch = 0 },
     });
 
-    lib_static.linkSystemLibrary("dbus-1");
-    lib_static.linkSystemLibrary("systemd");
-    lib_static.linkLibC();
-
-    b.installArtifact(lib_static);
+    b.installArtifact(lib);
 
     // -------------------------------------------------------------------------
     // Unit tests (no DBus session bus required)
     // -------------------------------------------------------------------------
 
-    const unit_tests = b.addTest(.{
+    const test_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
+    test_mod.linkSystemLibrary("dbus-1", .{});
+    test_mod.linkSystemLibrary("systemd", .{});
 
-    unit_tests.linkSystemLibrary("dbus-1");
-    unit_tests.linkSystemLibrary("systemd");
-    unit_tests.linkLibC();
+    const unit_tests = b.addTest(.{
+        .root_module = test_mod,
+    });
 
     const run_unit_tests = b.addRunArtifact(unit_tests);
 
@@ -122,15 +108,18 @@ pub fn build(b: *std.Build) void {
     // Integration tests (require DBus session bus)
     // -------------------------------------------------------------------------
 
-    const integration_tests = b.addTest(.{
+    const integ_mod = b.createModule(.{
         .root_source_file = b.path("test/integration_test.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
+    integ_mod.linkSystemLibrary("dbus-1", .{});
+    integ_mod.linkSystemLibrary("systemd", .{});
 
-    integration_tests.linkSystemLibrary("dbus-1");
-    integration_tests.linkSystemLibrary("systemd");
-    integration_tests.linkLibC();
+    const integration_tests = b.addTest(.{
+        .root_module = integ_mod,
+    });
 
     const run_integration_tests = b.addRunArtifact(integration_tests);
 
@@ -141,10 +130,6 @@ pub fn build(b: *std.Build) void {
     // Install to ~/.local/bin/ (user-local install)
     // -------------------------------------------------------------------------
 
-    const install_local = b.addInstallArtifact(exe, .{
-        .dest_dir = .{ .override = .{ .custom = "" } },
-    });
-
     const home = std.posix.getenv("HOME") orelse "/home/hyper";
     const local_bin = std.fmt.allocPrint(b.allocator, "{s}/.local/bin", .{home}) catch @panic("OOM");
 
@@ -155,27 +140,5 @@ pub fn build(b: *std.Build) void {
     });
     copy_cmd.addArtifactArg(exe);
     copy_cmd.addArg(local_bin);
-    copy_cmd.step.dependOn(&install_local.step);
     install_step.dependOn(&copy_cmd.step);
-
-    // -------------------------------------------------------------------------
-    // Documentation generation
-    // -------------------------------------------------------------------------
-
-    const docs = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = .Debug,
-    });
-
-    docs.linkSystemLibrary("dbus-1");
-    docs.linkSystemLibrary("systemd");
-    docs.linkLibC();
-
-    const docs_step = b.step("docs", "Generate documentation from source");
-    docs_step.dependOn(&b.addInstallDirectory(.{
-        .source_dir = docs.getEmittedDocs(),
-        .install_dir = .prefix,
-        .install_subdir = "docs",
-    }).step);
 }
diff --git a/src/interface/ffi/src/dbus.zig b/src/interface/ffi/src/dbus.zig
@@ -86,16 +86,16 @@ const DBUS_MESSAGE_TYPE_METHOD_CALL: c_int = 1;
 const DBUS_MESSAGE_TYPE_SIGNAL: c_int = 4;
 
 // libdbus-1 function declarations (extern C ABI).
-extern "dbus-1" fn dbus_error_init(error: *DBusError) void;
-extern "dbus-1" fn dbus_error_free(error: *DBusError) void;
-extern "dbus-1" fn dbus_error_is_set(error: *const DBusError) c_int;
+extern "dbus-1" fn dbus_error_init(err: *DBusError) void;
+extern "dbus-1" fn dbus_error_free(err: *DBusError) void;
+extern "dbus-1" fn dbus_error_is_set(err: *const DBusError) c_int;
 
-extern "dbus-1" fn dbus_bus_get(bus_type: c_int, error: *DBusError) ?*DBusConnection;
+extern "dbus-1" fn dbus_bus_get(bus_type: c_int, err: *DBusError) ?*DBusConnection;
 extern "dbus-1" fn dbus_bus_request_name(
     conn: *DBusConnection,
     name: [*:0]const u8,
     flags: c_uint,
-    error: *DBusError,
+    err: *DBusError,
 ) c_int;
 extern "dbus-1" fn dbus_bus_get_unique_name(conn: *DBusConnection) ?[*:0]const u8;
 
@@ -113,13 +113,13 @@ extern "dbus-1" fn dbus_connection_send_with_reply_and_block(
     conn: *DBusConnection,
     message: *DBusMessage,
     timeout_ms: c_int,
-    error: *DBusError,
+    err: *DBusError,
 ) ?*DBusMessage;
 extern "dbus-1" fn dbus_connection_add_filter(
     conn: *DBusConnection,
-    function: *const fn (?*DBusConnection, ?*DBusMessage, ?*anyopaque) callconv(.C) c_int,
+    function: *const fn (?*DBusConnection, ?*DBusMessage, ?*anyopaque) callconv(.c) c_int,
     user_data: ?*anyopaque,
-    free_data_function: ?*const fn (?*anyopaque) callconv(.C) void,
+    free_data_function: ?*const fn (?*anyopaque) callconv(.c) void,
 ) c_int;
 
 extern "dbus-1" fn dbus_message_new_method_call(
@@ -143,7 +143,7 @@ extern "dbus-1" fn dbus_message_append_args(
 ) c_int;
 extern "dbus-1" fn dbus_message_get_args(
     message: *DBusMessage,
-    error: *DBusError,
+    err: *DBusError,
     first_arg_type: c_int,
     ...,
 ) c_int;
@@ -449,7 +449,7 @@ pub fn callGetHealth(bus: *Connection) !?[]const u8 {
             last_err = err;
             if (attempt < MAX_RETRIES - 1) {
                 std.log.warn("GetHealth attempt {d} failed, retrying...", .{attempt + 1});
-                std.time.sleep(RETRY_DELAY_NS);
+                std.Thread.sleep(RETRY_DELAY_NS);
                 continue;
             }
             return last_err;
@@ -524,7 +524,7 @@ fn methodFilter(
     conn: ?*DBusConnection,
     msg: ?*DBusMessage,
     _: ?*anyopaque,
-) callconv(.C) c_int {
+) callconv(.c) c_int {
     const message = msg orelse return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     const connection = conn orelse return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
diff --git a/src/interface/ffi/src/main.zig b/src/interface/ffi/src/main.zig
@@ -76,7 +76,7 @@ var reload_requested = std.atomic.Value(bool).init(false);
 
 /// POSIX signal handler — sets atomic flags for the main loop to pick up.
 /// Signal handlers must be async-signal-safe, so we only write to atomics.
-fn signalHandler(sig: c_int) callconv(.C) void {
+fn signalHandler(sig: c_int) callconv(.c) void {
     switch (sig) {
         posix.SIG.HUP => {
             // SIGHUP: reload configuration without restarting.
@@ -95,17 +95,17 @@ fn signalHandler(sig: c_int) callconv(.C) void {
 }
 
 /// Install POSIX signal handlers for SIGHUP, SIGTERM, SIGINT, SIGUSR1.
-fn installSignalHandlers() !void {
+fn installSignalHandlers() void {
     const handler: posix.Sigaction = .{
         .handler = .{ .handler = signalHandler },
-        .mask = posix.empty_sigset,
+        .mask = posix.sigemptyset(),
         .flags = posix.SA.RESTART,
     };
 
-    try posix.sigaction(posix.SIG.HUP, &handler, null);
-    try posix.sigaction(posix.SIG.TERM, &handler, null);
-    try posix.sigaction(posix.SIG.INT, &handler, null);
-    try posix.sigaction(posix.SIG.USR1, &handler, null);
+    posix.sigaction(posix.SIG.HUP, &handler, null);
+    posix.sigaction(posix.SIG.TERM, &handler, null);
+    posix.sigaction(posix.SIG.INT, &handler, null);
+    posix.sigaction(posix.SIG.USR1, &handler, null);
 }
 
 // ---------------------------------------------------------------------------
@@ -144,12 +144,13 @@ fn parseArgs(allocator: std.mem.Allocator) !?Config {
                 return error.InvalidArgs;
             };
         } else if (std.mem.eql(u8, arg, "--version")) {
-            const stdout = std.io.getStdOut().writer();
-            try stdout.print("{s}\n", .{BUILD_INFO});
+            const out = std.fs.File.stdout();
+            try out.writeAll(BUILD_INFO);
+            try out.writeAll("\n");
             return null;
         } else if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
-            const stdout = std.io.getStdOut().writer();
-            try stdout.writeAll(
+            const out = std.fs.File.stdout();
+            try out.writeAll(
                 \\session-sentinel-tray — KDE/Wayland system tray for Session Sentinel
                 \\
                 \\Usage: session-sentinel-tray [OPTIONS]
@@ -272,7 +273,7 @@ fn monitorLoop(
                 std.log.info("Immediate rescan requested (SIGUSR1)", .{});
                 break;
             }
-            std.time.sleep(check_interval_ns);
+            std.Thread.sleep(check_interval_ns);
             elapsed += check_interval_ns;
         }
     }
@@ -331,7 +332,7 @@ pub fn main() !void {
     std.log.info("{s} starting", .{BUILD_INFO});
 
     // Install signal handlers before any threads are spawned.
-    try installSignalHandlers();
+    installSignalHandlers();
 
     // Ensure the icon temp directory exists.
     try icons.ensureTempDir();
@@ -375,7 +376,7 @@ pub fn main() !void {
         while (!shutdown_requested.load(.acquire)) {
             bus.processMessages(100) catch |err| {
                 std.log.err("DBus message processing error: {any}", .{err});
-                std.time.sleep(100 * std.time.ns_per_ms);
+                std.Thread.sleep(100 * std.time.ns_per_ms);
             };
 
             // Handle flash timer for purple zone.
diff --git a/src/interface/ffi/src/tray.zig b/src/interface/ffi/src/tray.zig
@@ -30,7 +30,7 @@ const icons = @import("icons.zig");
 
 /// Health zone derived from monitoring metrics.
 /// Determines the tray icon, tooltip text, and urgency level.
-pub const HealthZone = enum {
+pub const HealthZone = enum(u8) {
     /// All clear — session data within safe limits.
     green,
 
