commands.zig

1// commands.zig — all command handlers2// Orchestrates exec/api/output. Zero direct stdout writes.3const std = @import("std");4const builtin = @import("builtin");5const types = @import("types.zig");6const errors = @import("errors.zig");7const config = @import("config.zig");8const output = @import("output.zig");9const exec = @import("exec.zig");10const api = @import("api.zig");11const search_tui = @import("search.zig");12const version = @import("version.zig");1314const UPDATE_URL = "https://kepr.uk/api/nina/releases/latest";1516pub const Ctx = struct {17    gpa: std.mem.Allocator,18    io: std.Io,19    environ: *const std.process.Environ.Map,20    machine: types.Machine,21    cfg: types.NinaConfig,22    args: []const []const u8,   // positional args after subcommand23    sub: []const u8,            // subcommand (e.g. "list" in "service list")24    dry: bool,25    check: bool,26    no_apply: bool,27    all: bool,28    last: u32,29    json: bool,30};3132pub fn apply(ctx: Ctx) !void {33    if (ctx.dry) {34        output.applyDry(ctx.machine.name);35        const code = try exec.nixosRebuildDryActivate(ctx.io, &ctx.machine, ctx.gpa);36        if (code != 0) return error.BuildFailed;37        output.applyDryDone();38        return;39    }40    if (ctx.check) {41        return check(ctx);42    }4344    output.applyStart(ctx.machine.name);45    const start = std.Io.Clock.awake.now(ctx.io);4647    const code = exec.nixosRebuildSwitch(ctx.io, &ctx.machine, ctx.gpa) catch |e| {48        exec.markApplyFailed(ctx.io, ctx.environ);49        output.applyFailed("");50        return e;51    };5253    if (code != 0) {54        exec.markApplyFailed(ctx.io, ctx.environ);55        output.applyFailed("");56        return error.BuildFailed;57    }5859    const elapsed_ns = @max(0, start.untilNow(ctx.io, .awake).toNanoseconds());60    const elapsed: u64 = @intCast(@divFloor(elapsed_ns, 1_000_000));61    const gen = exec.getCurrentGeneration(ctx.gpa, ctx.io, &ctx.machine) catch 0;62    const after_failure = exec.takeApplyFailed(ctx.io, ctx.environ);63    output.applyDone(gen, elapsed, after_failure);64    logAction(ctx, "apply", gen);65}6667pub fn check(ctx: Ctx) !void {68    output.checkStart(ctx.machine.name);69    const code = try exec.nixosRebuildBuild(ctx.io, &ctx.machine, ctx.gpa);70    if (code != 0) {71        output.checkFailed("");72        return error.BuildFailed;73    }74    output.checkOk();75}7677pub fn back(ctx: Ctx) !void {78    const gens = try exec.getGenerations(ctx.gpa, ctx.io, &ctx.machine);79    defer ctx.gpa.free(gens);8081    var current: u32 = 0;82    for (gens) |g| if (g.current) { current = g.number; };8384    // Newest generation older than current. If there is none, we're already at the85    // oldest — stop cleanly instead of letting rollback fail with 'build failed'.86    var prev: u32 = 0;87    var has_prev = false;88    for (gens) |g| {89        if (g.number < current and (!has_prev or g.number > prev)) {90            prev = g.number;91            has_prev = true;92        }93    }94    if (!has_prev) {95        output.alreadyOldest();96        return;97    }9899    output.backStart(ctx.machine.name, current, prev);100    if (ctx.cfg.confirm and !output.confirm("")) return;101102    const code = try exec.rollback(ctx.io, &ctx.machine, ctx.gpa);103    if (code != 0) return error.BuildFailed;104    output.backDone(prev);105}106107pub fn go(ctx: Ctx) !void {108    if (ctx.args.len == 0) return error.Internal;109    const target = std.fmt.parseInt(u32, ctx.args[0], 10) catch return error.Internal;110    const current = try exec.getCurrentGeneration(ctx.gpa, ctx.io, &ctx.machine);111112    output.goStart(ctx.machine.name, current, target);113    if (ctx.cfg.confirm and !output.confirm("")) return;114115    const code = try exec.switchGeneration(ctx.io, &ctx.machine, ctx.gpa, target);116    if (code != 0) return error.ProcessFailed;117    output.generationDone(target);118}119120pub fn history(ctx: Ctx) !void {121    const gens = try exec.getGenerations(ctx.gpa, ctx.io, &ctx.machine);122    defer ctx.gpa.free(gens);123    output.historyHeader(ctx.machine.name);124    for (gens) |g| output.historyRow(g);125}126127pub fn genCmd(ctx: Ctx) !void {128    if (std.mem.eql(u8, ctx.sub, "list")) return history(ctx);129    if (std.mem.eql(u8, ctx.sub, "current")) {130        const n = try exec.getCurrentGeneration(ctx.gpa, ctx.io, &ctx.machine);131        output.genCurrent(n);132        return;133    }134    if (std.mem.eql(u8, ctx.sub, "delete")) {135        if (ctx.args.len == 0) return error.Internal;136        if (std.mem.eql(u8, ctx.args[0], "old")) {137            if (ctx.cfg.confirm and !output.confirm("")) return;138            _ = try exec.deleteOldGenerations(ctx.io, &ctx.machine, ctx.gpa);139        } else {140            const n = std.fmt.parseInt(u32, ctx.args[0], 10) catch return error.Internal;141            if (ctx.cfg.confirm and !output.confirm("")) return;142            _ = try exec.deleteGeneration(ctx.io, &ctx.machine, ctx.gpa, n);143        }144        output.done();145        return;146    }147    return error.Internal;148}149150pub fn clean(ctx: Ctx) !void {151    const gens = try exec.getGenerations(ctx.gpa, ctx.io, &ctx.machine);152    defer ctx.gpa.free(gens);153    const all = ctx.all or std.mem.eql(u8, ctx.sub, "all");154    const total: u32 = @intCast(gens.len);155    // `clean all` keeps only the current generation; otherwise keep the configured156    // count. With nothing older than the keep limit, there's nothing to collect.157    const keep: u32 = if (all) 1 else ctx.cfg.generations;158    if (total <= keep) {159        output.cleanNothing(ctx.machine.name, total);160        return;161    }162    output.cleanStart(ctx.machine.name, keep, total);163    if (ctx.cfg.confirm and !output.confirm("removing — cannot be undone")) return;164    _ = try exec.collectGarbage(ctx.io, &ctx.machine, ctx.gpa, all, ctx.cfg.generations);165    output.cleanDone();166}167168pub fn statusCmd(ctx: Ctx) !void {169    output.statusHeader();170    // --all renders every configured machine; remotes route through the same SSH171    // path as exec.capture. An unreachable machine is shown in red, not fatal.172    if (ctx.all and ctx.cfg.machines.len > 0) {173        for (ctx.cfg.machines) |m| statusRowFor(ctx, &m);174        return;175    }176    statusRowFor(ctx, &ctx.machine);177}178179fn statusRowFor(ctx: Ctx, machine: *const types.Machine) void {180    // A failure to read the current generation means we couldn't reach or query181    // the machine — mark it unreachable rather than reporting a bogus gen 0.182    const gen = exec.getCurrentGeneration(ctx.gpa, ctx.io, machine) catch {183        output.statusRow(machine.name, 0, "", "", false);184        return;185    };186    const st = exec.systemStatus(ctx.gpa, ctx.io, machine);187    defer ctx.gpa.free(st.size);188    defer ctx.gpa.free(st.age);189    output.statusRow(machine.name, gen, st.age, st.size, true);190}191192pub fn diff(ctx: Ctx) !void {193    const gens = try exec.getGenerations(ctx.gpa, ctx.io, &ctx.machine);194    defer ctx.gpa.free(gens);195    var current: u32 = 0;196    var prev: u32 = 0;197    for (gens) |g| {198        if (g.current) current = g.number;199        if (!g.current and g.number > prev and g.number < current) prev = g.number;200    }201    if (ctx.args.len >= 2) {202        const a = std.fmt.parseInt(u32, ctx.args[0], 10) catch current - 1;203        const b = std.fmt.parseInt(u32, ctx.args[1], 10) catch current;204        output.diffHeader(a, b, ctx.machine.name);205        if (try exec.diffClosures(ctx.io, &ctx.machine, ctx.gpa, a, b) != 0) return error.ProcessFailed;206    } else {207        output.diffHeader(if (prev > 0) prev else current - 1, current, ctx.machine.name);208        if (try exec.diffClosures(ctx.io, &ctx.machine, ctx.gpa, if (prev > 0) prev else current - 1, current) != 0) return error.ProcessFailed;209    }210}211212pub fn mood(ctx: Ctx) !void {213    const gen = exec.getCurrentGeneration(ctx.gpa, ctx.io, &ctx.machine) catch 0;214    const st = exec.systemStatus(ctx.gpa, ctx.io, &ctx.machine);215    defer ctx.gpa.free(st.size);216    defer ctx.gpa.free(st.age);217    const state = exec.systemRunningState(ctx.gpa, ctx.io, &ctx.machine) catch try ctx.gpa.dupe(u8, "unknown");218    defer ctx.gpa.free(state);219    output.mood(ctx.machine.name, state, gen, st.age, st.size);220}221222pub fn doctor(ctx: Ctx) !void {223    output.doctorHeader(ctx.machine.name);224    const checks = try exec.runDoctorChecks(ctx.gpa, ctx.io, &ctx.machine);225    defer ctx.gpa.free(checks);226    var warnings: u32 = 0;227    var failures: u32 = 0;228    for (checks) |ch| {229        output.doctorRow(ch);230        if (ch.status == .warn) warnings += 1;231        if (ch.status == .fail) failures += 1;232    }233    output.doctorSummary(warnings, failures);234}235236// nina update — kepr self-update for the nina binary itself.237pub fn update(ctx: Ctx) !void {238    output.updateSelfStart();239240    if (comptime std.mem.eql(u8, version.PLATFORM, "unsupported")) {241        output.updateSelfNoPlatform(@tagName(builtin.cpu.arch) ++ "-" ++ @tagName(builtin.os.tag));242        return error.Internal;243    }244245    const env_url = ctx.environ.get("NINA_UPDATE_SOURCE");246    const source_url = env_url orelse UPDATE_URL;247248    const body = exec.fetchUrl(ctx.gpa, ctx.io, source_url) catch |e| switch (e) {249        error.NetworkError, error.HttpError => {250            output.updateSelfNetworkError();251            return;252        },253        else => return e,254    };255    defer ctx.gpa.free(body);256257    const parsed = std.json.parseFromSlice(std.json.Value, ctx.gpa, body, .{}) catch {258        output.printWarning("could not parse release metadata");259        return;260    };261    defer parsed.deinit();262263    const root = parsed.value;264    if (root != .object) { output.printWarning("malformed release metadata"); return; }265266    const remote_ver = blk: {267        const v = root.object.get("version") orelse { output.printWarning("malformed release metadata"); return; };268        break :blk switch (v) { .string => |s| s, else => { output.printWarning("malformed release metadata"); return; } };269    };270271    if (std.mem.eql(u8, remote_ver, version.VERSION)) {272        output.updateSelfCurrent(version.VERSION);273        return;274    }275276    output.updateSelfAvailable(version.VERSION, remote_ver);277    if (ctx.check) return;278279    var exe_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;280    const install_path = exec.selfExePath(ctx.io, &exe_buf) catch {281        errors.error_info.setMessage("could not determine install path", .{});282        return error.Internal;283    };284285    // When running from the nix store, defer to nix profile upgrade so nix286    // manages the transition (the store is read-only; binary replacement fails).287    // A NixOS system install also resolves into the store but isn't a profile288    // element, so check the profile to avoid a no-op `upgrade` — it updates with289    // the next nixos-rebuild instead.290    if (std.mem.startsWith(u8, install_path, "/nix/store/")) {291        const nina_element = exec.profileNinaElement(ctx.gpa, ctx.io, &ctx.machine);292        defer {293            if (nina_element) |n| ctx.gpa.free(n);294        }295        if (nina_element == null) {296            output.updateSelfNotInProfile();297            return;298        }299        const element = nina_element.?;300        output.updateSelfNixManaged(remote_ver);301        if (ctx.cfg.confirm and !output.confirm("")) return;302        const ec = exec.streamLocal(ctx.io, &.{ "nix", "profile", "upgrade", element }) catch {303            output.updateSelfNixFailed();304            return;305        };306        if (ec != 0) output.updateSelfNixFailed();307        return;308    }309310    const plat_info = blk: {311        const pv = root.object.get("platforms") orelse break :blk null;312        if (pv != .object) break :blk null;313        break :blk pv.object.get(version.PLATFORM);314    };315    if (plat_info == null) { output.updateSelfNoPlatform(version.PLATFORM); return; }316317    const dl_url = blk: {318        const v = plat_info.?.object.get("url") orelse { output.printWarning("malformed release metadata"); return; };319        break :blk switch (v) { .string => |s| s, else => { output.printWarning("malformed release metadata"); return; } };320    };321322    const raw_cksum = blk: {323        if (plat_info.?.object.get("blake3")) |v|324            break :blk switch (v) { .string => |s| s, else => { output.printWarning("malformed release metadata"); return; } };325        if (plat_info.?.object.get("checksum")) |v|326            break :blk switch (v) { .string => |s| s, else => { output.printWarning("malformed release metadata"); return; } };327        output.printWarning("missing checksum in release metadata");328        return;329    };330    const expected_hex = if (std.mem.startsWith(u8, raw_cksum, "blake3:")) raw_cksum["blake3:".len..] else raw_cksum;331332    if (ctx.cfg.confirm and !output.confirm("")) return;333334    output.updateSelfDownloading(remote_ver, version.PLATFORM);335    const tmp_path = exec.downloadToTemp(ctx.gpa, ctx.io, dl_url) catch {336        output.printWarning("download failed — check your connection and try again");337        return;338    };339    defer ctx.gpa.free(tmp_path);340341    output.updateSelfVerifying();342    exec.verifyAndInstall(ctx.gpa, ctx.io, tmp_path, expected_hex, install_path) catch |e| switch (e) {343        error.ChecksumMismatch => { output.updateSelfChecksumFailed(); return; },344        else => return e,345    };346347    output.updateSelfDone(version.VERSION, remote_ver);348}349350// nina goodbye — clean uninstall. Three install paths:351// - nix profile (binary in nix store with a profile element) → nix profile remove352// - koh build or source build (plain binary on PATH) → delete the file353pub fn goodbye(ctx: Ctx) !void {354    output.goodbyeStart();355356    var exe_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;357    const install_path = exec.selfExePath(ctx.io, &exe_buf) catch {358        errors.error_info.setMessage("could not determine install path", .{});359        return error.Internal;360    };361362    // A binary outside the nix store is a koh build or source build — delete it.363    if (!std.mem.startsWith(u8, install_path, "/nix/store/")) {364        output.goodbyeFile(install_path);365        if (ctx.cfg.confirm and !output.confirm("")) return;366        std.Io.Dir.deleteFileAbsolute(ctx.io, install_path) catch |e| {367            errors.error_info.setMessage("could not remove {s}", .{install_path});368            return e;369        };370        output.goodbyeDone();371        return;372    }373374    // Binary is in the nix store — find and remove the profile element.375    const nina_element = exec.profileNinaElement(ctx.gpa, ctx.io, &ctx.machine);376    defer {377        if (nina_element) |n| ctx.gpa.free(n);378    }379380    if (nina_element == null) {381        errors.error_info.setMessage("nina not found in nix profile — was it installed via 'nix profile add'?", .{});382        return error.Internal;383    }384385    output.goodbyeNix();386    if (ctx.cfg.confirm and !output.confirm("")) return;387    const ec = exec.streamLocal(ctx.io, &.{ "nix", "profile", "remove", nina_element.? }) catch {388        output.goodbyeFailed("nix profile remove failed");389        return;390    };391    if (ec != 0) {392        output.goodbyeFailed("nix profile remove failed");393        return;394    }395    output.goodbyeDone();396}397398fn channelUpdateCmd(ctx: Ctx) !void {399    output.updateStart(ctx.machine.name);400    _ = try exec.channelUpdate(ctx.io, &ctx.machine, ctx.gpa);401    output.updateDone();402}403404pub fn upgrade(ctx: Ctx) !void {405    output.upgradeStart(ctx.machine.name);406    output.printSubstep("updating channels", .{});407    _ = exec.channelUpdate(ctx.io, &ctx.machine, ctx.gpa) catch {};408    output.printSubstep("rebuilding", .{});409    const start = std.Io.Clock.awake.now(ctx.io);410    const code = try exec.nixosRebuildSwitch(ctx.io, &ctx.machine, ctx.gpa);411    if (code != 0) {412        output.applyFailed("");413        return error.BuildFailed;414    }415    const elapsed_ns = @max(0, start.untilNow(ctx.io, .awake).toNanoseconds());416    const elapsed: u64 = @intCast(@divFloor(elapsed_ns, 1_000_000));417    const gen = exec.getCurrentGeneration(ctx.gpa, ctx.io, &ctx.machine) catch 0;418    output.applyDone(gen, elapsed, false);419}420421pub fn log(ctx: Ctx) !void {422    output.logHeader(ctx.machine.name);423    const content = exec.readNinaLog(ctx.gpa, ctx.io, ctx.environ, ctx.last) catch {424        // No log yet — that's fine425        return;426    };427    defer ctx.gpa.free(content);428    var lines = std.mem.splitScalar(u8, content, '\n');429    while (lines.next()) |line| {430        const t = std.mem.trim(u8, line, " \t\r");431        if (t.len == 0) continue;432        if (t[0] == '{') {433            renderJsonLogLine(ctx.gpa, t);434        } else {435            // legacy tab-separated format436            var parts = std.mem.tokenizeScalar(u8, t, '\t');437            const date = parts.next() orelse continue;438            const time = parts.next() orelse "";439            const action = parts.next() orelse "";440            const detail = parts.next() orelse "";441            output.logRow(date, time, action, detail);442        }443    }444}445446// The on-disk log is JSON Lines: {"ts","machine","command","outcome","gen_after",...}.447// Render ts -> date/time columns, command -> action, outcome(+gen) -> detail.448fn renderJsonLogLine(gpa: std.mem.Allocator, line: []const u8) void {449    const parsed = std.json.parseFromSlice(std.json.Value, gpa, line, .{}) catch {450        output.logRow(line, "", "", ""); // unparseable — show raw rather than drop451        return;452    };453    defer parsed.deinit();454    if (parsed.value != .object) return;455    const o = parsed.value.object;456457    const ts = jsonStr(o, "ts");458    const date = if (ts.len >= 10) ts[0..10] else ts;459    const time = if (ts.len >= 16) ts[11..16] else "";460    const action = jsonStr(o, "command");461    const outcome = jsonStr(o, "outcome");462463    var buf: [160]u8 = undefined;464    var detail: []const u8 = outcome;465    if (o.get("gen_after")) |g| {466        if (g == .integer) {467            detail = std.fmt.bufPrint(&buf, "{s}   -> gen {d}", .{ outcome, g.integer }) catch outcome;468        }469    }470    output.logRow(date, time, action, detail);471}472473fn jsonStr(o: std.json.ObjectMap, key: []const u8) []const u8 {474    if (o.get(key)) |v| {475        if (v == .string) return v.string;476    }477    return "";478}479480pub fn edit(ctx: Ctx) !void {481    const hardware = ctx.args.len > 0 and std.mem.eql(u8, ctx.args[0], "hardware");482    const filename = if (hardware) "hardware-configuration.nix" else "configuration.nix";483    const path = try std.fmt.allocPrint(ctx.gpa, "{s}/{s}", .{ ctx.machine.config_path, filename });484    defer ctx.gpa.free(path);485    output.editOpen(path, ctx.cfg.editor);486    _ = try exec.openEditor(ctx.io, ctx.gpa, ctx.cfg.editor, path, null);487}488489pub fn fmt(ctx: Ctx) !void {490    const path = try std.fmt.allocPrint(ctx.gpa, "{s}/configuration.nix", .{ctx.machine.config_path});491    defer ctx.gpa.free(path);492    if (ctx.check) {493        const code = try exec.nixpkgsFmt(ctx.io, &ctx.machine, ctx.gpa, path, true);494        if (code != 0) output.fmtNeedsFormat() else output.fmtDone();495        return;496    }497    output.fmtStart(path);498    _ = try exec.nixpkgsFmt(ctx.io, &ctx.machine, ctx.gpa, path, false);499    output.fmtDone();500}501502pub fn repl(ctx: Ctx) !void {503    output.replStart();504    _ = try exec.nixRepl(ctx.io, &ctx.machine, ctx.gpa);505}506507pub fn develop(ctx: Ctx) !void {508    if (std.mem.eql(u8, ctx.sub, "show")) {509        _ = try exec.nixBuild(ctx.io, &ctx.machine, ctx.gpa, null);510        return;511    }512    const run_cmd: ?[]const u8 = if (ctx.args.len > 0 and std.mem.eql(u8, ctx.sub, "run"))513        ctx.args[0]514    else515        null;516    output.developStart(&.{});517    _ = try exec.nixDevelop(ctx.io, &ctx.machine, ctx.gpa, run_cmd);518    output.developDone();519}520521pub fn info(ctx: Ctx) !void {522    output.infoHeader(ctx.machine.name);523    const nixos_ver = exec.systemInfo(ctx.gpa, ctx.io, &ctx.machine) catch try ctx.gpa.dupe(u8, "unknown");524    defer ctx.gpa.free(nixos_ver);525    output.infoRow("nixos", std.mem.trim(u8, nixos_ver, " \t\n\r"));526527    const kernel = exec.kernelInfo(ctx.gpa, ctx.io, &ctx.machine) catch try ctx.gpa.dupe(u8, "unknown");528    defer ctx.gpa.free(kernel);529    output.infoRow("kernel", std.mem.trim(u8, kernel, " \t\n\r"));530531    const uptime = exec.uptimeInfo(ctx.gpa, ctx.io, &ctx.machine) catch try ctx.gpa.dupe(u8, "unknown");532    defer ctx.gpa.free(uptime);533    output.infoRow("uptime", std.mem.trim(u8, uptime, " \t\n\r"));534}535536pub fn boot(ctx: Ctx) !void {537    output.bootHeader(ctx.machine.name);538    const entries = exec.bootEntries(ctx.gpa, ctx.io, &ctx.machine) catch &.{};539    defer ctx.gpa.free(entries);540    for (entries, 0..) |entry, i| output.bootEntry(entry, i);541}542543pub fn searchCmd(ctx: Ctx) !void {544    const query = if (ctx.args.len > 0) ctx.args[0] else "";545    api.ensureRegistryPinned(ctx.gpa, ctx.io, ctx.environ);546    const selected = try search_tui.run(ctx.gpa, ctx.io, query, .packages);547    if (selected) |npkg| try selectAndInstall(ctx, npkg);548}549550pub fn optionCmd(ctx: Ctx) !void {551    const query = if (ctx.args.len > 0) ctx.args[0] else "";552    api.ensureRegistryPinned(ctx.gpa, ctx.io, ctx.environ);553    _ = try search_tui.run(ctx.gpa, ctx.io, query, .options);554}555556pub fn install(ctx: Ctx) !void {557    const pkg_name = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;558559    api.ensureRegistryPinned(ctx.gpa, ctx.io, ctx.environ);560561    // Search for the package to get the attr562    const pkgs = api.searchPackages(ctx.gpa, ctx.io, pkg_name) catch {563        errors.error_info.setMessage("'{s}' not found in nixpkgs", .{pkg_name});564        errors.error_info.setSuggestion("nina search {s}", .{pkg_name});565        return error.PackageNotFound;566    };567568    if (pkgs.len == 0) {569        // No matches — likely a typo. Suggest the closest real package and offer it.570        if (closestPackage(ctx, pkg_name)) |sugg| {571            output.didYouMean(pkg_name, sugg.pname);572            if (output.confirm("")) try selectAndInstall(ctx, sugg);573            return;574        }575        errors.error_info.setMessage("'{s}' not found in nixpkgs", .{pkg_name});576        errors.error_info.setSuggestion("nina search {s}", .{pkg_name});577        return error.PackageNotFound;578    }579580    // Prefer an exact name match over the first search result — `install ripgrep`581    // must pick "ripgrep", not the alphabetically-first match like "repgrep".582    var found = pkgs[0];583    for (pkgs) |p| {584        if (std.mem.eql(u8, p.pname, pkg_name)) {585            found = p;586            break;587        }588    }589    try selectAndInstall(ctx, found);590}591592// Find the real package whose name is closest to a not-found query (typo help).593// Typos usually keep the leading characters, so gather candidates with a prefix594// search and rank by edit distance; return the best only if it's typo-close.595fn closestPackage(ctx: Ctx, query: []const u8) ?types.NixPackage {596    if (query.len < 2) return null;597    var candidates = api.searchPackages(ctx.gpa, ctx.io, query[0..@min(query.len, 4)]) catch &.{};598    if (candidates.len == 0 and query.len > 2) {599        candidates = api.searchPackages(ctx.gpa, ctx.io, query[0..2]) catch &.{};600    }601    if (candidates.len == 0) return null;602603    var best: ?types.NixPackage = null;604    var best_dist: usize = std.math.maxInt(usize);605    for (candidates) |p| {606        const d = editDistance(query, p.pname);607        if (d > 0 and d < best_dist) {608            best_dist = d;609            best = p;610        }611    }612    // Only suggest a genuinely close name, scaled to query length.613    const threshold = @max(@as(usize, 2), query.len / 3);614    return if (best_dist <= threshold) best else null;615}616617// Case-insensitive Levenshtein distance. Names longer than the row buffer are618// treated as far away (never suggested).619fn editDistance(a: []const u8, b: []const u8) usize {620    const n = b.len;621    if (a.len == 0) return n;622    if (n == 0) return a.len;623    if (n + 1 > 128) return std.math.maxInt(usize);624    var prev: [128]usize = undefined;625    var curr: [128]usize = undefined;626    var j: usize = 0;627    while (j <= n) : (j += 1) prev[j] = j;628    var i: usize = 1;629    while (i <= a.len) : (i += 1) {630        curr[0] = i;631        j = 1;632        while (j <= n) : (j += 1) {633            const cost: usize = if (std.ascii.toLower(a[i - 1]) == std.ascii.toLower(b[j - 1])) 0 else 1;634            curr[j] = @min(prev[j] + 1, @min(curr[j - 1] + 1, prev[j - 1] + cost));635        }636        @memcpy(prev[0 .. n + 1], curr[0 .. n + 1]);637    }638    return prev[n];639}640641test "editDistance is case-insensitive Levenshtein" {642    try std.testing.expectEqual(@as(usize, 1), editDistance("firefux", "firefox"));643    try std.testing.expectEqual(@as(usize, 0), editDistance("git", "GIT"));644    try std.testing.expectEqual(@as(usize, 2), editDistance("fierfox", "firefox"));645    try std.testing.expectEqual(@as(usize, 7), editDistance("", "firefox"));646}647648// Prompt for the install method (profile / system / try) and dispatch. Shared by649// `nina install <pkg>` and the search widget's Enter-to-select — the letter keys650// are read here, after the search widget's raw mode is gone, so they don't651// collide with typing a query.652fn selectAndInstall(ctx: Ctx, npkg: types.NixPackage) !void {653    output.installSelectPrompt(npkg.pname, npkg.version);654655    var choice_buf: [8]u8 = undefined;656    var choice_len: usize = 0;657    while (choice_len < choice_buf.len) {658        const n = std.posix.read(std.posix.STDIN_FILENO, choice_buf[choice_len .. choice_len + 1]) catch break;659        if (n == 0) break;660        if (choice_buf[choice_len] == '\n') break;661        choice_len += 1;662    }663    const choice = std.mem.trim(u8, choice_buf[0..choice_len], " \t");664665    if (choice.len == 0 or choice[0] == 'i' or choice[0] == 'I') {666        try profileInstallPkg(ctx, npkg);667    } else if (choice[0] == 's' or choice[0] == 'S') {668        try systemInstallPkg(ctx, npkg);669    } else if (choice[0] == 't' or choice[0] == 'T') {670        try tryPkg(ctx, npkg);671    }672}673674fn profileInstallPkg(ctx: Ctx, npkg: types.NixPackage) !void {675    output.installStart(npkg.pname, .profile);676    output.printSubstep("nix profile add nixpkgs#{s}", .{npkg.attr});677    output.printTeach(try std.fmt.allocPrint(ctx.gpa, "nix profile add nixpkgs#{s}", .{npkg.attr}));678    const code = try exec.profileInstall(ctx.io, &ctx.machine, ctx.gpa, npkg.attr);679    if (code != 0) return error.ProcessFailed;680    output.installDone(npkg.pname);681}682683fn systemInstallPkg(ctx: Ctx, npkg: types.NixPackage) !void {684    const config_path = try std.fmt.allocPrint(ctx.gpa, "{s}/configuration.nix", .{ctx.machine.config_path});685    defer ctx.gpa.free(config_path);686    const line = api.findSystemPackagesLine(ctx.io, config_path) orelse 1;687    output.installEditorPrompt(npkg.pname, config_path, line, ctx.cfg.editor);688    _ = try exec.openEditor(ctx.io, ctx.gpa, ctx.cfg.editor, config_path, line);689    if (ctx.cfg.confirm) {690        if (output.confirm("apply now? ")) {691            try apply(ctx);692        }693    }694}695696fn tryPkg(ctx: Ctx, npkg: types.NixPackage) !void {697    output.tryStart(npkg.pname);698    output.printSubstep("nix shell nixpkgs#{s}", .{npkg.attr});699    _ = try exec.nixShell(ctx.io, &ctx.machine, ctx.gpa, npkg.attr);700    output.tryDone();701}702703pub fn remove(ctx: Ctx) !void {704    const pkg_name = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;705    output.removeStart(pkg_name);706    const code = try exec.profileRemove(ctx.io, &ctx.machine, ctx.gpa, pkg_name);707    if (code != 0) return error.ProcessFailed;708    output.done();709}710711pub fn list(ctx: Ctx) !void {712    output.listHeader(ctx.machine.name);713714    // Profile packages: parse `nix profile list --json` into clean name+version715    // rows instead of dumping nix's verbose multi-line "Name:/Flake attribute:"716    // blocks.717    if (exec.profileListJson(ctx.gpa, ctx.io, &ctx.machine) catch null) |json| {718        defer ctx.gpa.free(json);719        output.listSection("profile");720        renderProfileJson(ctx.gpa, json);721    }722723    // System packages: the references of /run/current-system/sw, each a724    // <hash>-<name>-<version> store path.725    if (exec.systemPackagePaths(ctx.gpa, ctx.io, &ctx.machine) catch null) |paths| {726        defer ctx.gpa.free(paths);727        output.blankLine();728        output.listSection("system");729        var lines = std.mem.splitScalar(u8, paths, '\n');730        while (lines.next()) |line| {731            const t = std.mem.trim(u8, line, " \t\r");732            if (t.len == 0) continue;733            const row = pkgFromStorePath(t);734            // Skip support paths with no parseable version (man pages, wrappers).735            if (row.version.len == 0) continue;736            output.listPkg(row.name, row.version);737        }738    }739}740741const PkgRow = struct { name: []const u8, version: []const u8 };742743// Split a nix store path basename (<hash>-<name>-<version>) into name + version.744// Version begins at the first '-' followed by a digit, which reliably lands on745// the name/version boundary since the 32-char hash and package names start with746// non-digits.747fn pkgFromStorePath(path: []const u8) PkgRow {748    const base = std.fs.path.basename(path);749    const after_hash = if (base.len > 33 and base[32] == '-') base[33..] else base;750    var i: usize = 0;751    while (i + 1 < after_hash.len) : (i += 1) {752        if (after_hash[i] == '-' and std.ascii.isDigit(after_hash[i + 1])) {753            return .{ .name = after_hash[0..i], .version = stripOutputSuffix(after_hash[i + 1 ..]) };754        }755    }756    return .{ .name = after_hash, .version = "" };757}758759// Multi-output derivations append the output name to the store path (e.g.760// curl-8.20.0-bin, less-692-man). Strip that suffix so the version column reads761// as just the version.762fn stripOutputSuffix(ver: []const u8) []const u8 {763    const suffixes = [_][]const u8{ "-bin", "-man", "-dev", "-doc", "-lib", "-info", "-out", "-static", "-devdoc" };764    for (suffixes) |s| {765        if (std.mem.endsWith(u8, ver, s)) return ver[0 .. ver.len - s.len];766    }767    return ver;768}769770test "pkgFromStorePath splits name and version at first dash-digit" {771    const a = pkgFromStorePath("/nix/store/abcdefghijklmnopqrstuvwxyz012345-ripgrep-15.1.0");772    try std.testing.expectEqualStrings("ripgrep", a.name);773    try std.testing.expectEqualStrings("15.1.0", a.version);774775    const b = pkgFromStorePath("/nix/store/abcdefghijklmnopqrstuvwxyz012345-helix-25.01");776    try std.testing.expectEqualStrings("helix", b.name);777    try std.testing.expectEqualStrings("25.01", b.version);778779    // multi-output store paths drop their output-name suffix780    const c = pkgFromStorePath("/nix/store/abcdefghijklmnopqrstuvwxyz012345-curl-8.20.0-bin");781    try std.testing.expectEqualStrings("curl", c.name);782    try std.testing.expectEqualStrings("8.20.0", c.version);783}784785fn firstStorePath(el: std.json.Value) ?[]const u8 {786    if (el != .object) return null;787    const sp = el.object.get("storePaths") orelse return null;788    if (sp != .array or sp.array.items.len == 0) return null;789    const first = sp.array.items[0];790    return if (first == .string) first.string else null;791}792793// `nix profile list --json` has two shapes across nix versions: newer keys each794// element by name (object), older lists them positionally (array). Handle both.795fn renderProfileJson(gpa: std.mem.Allocator, json: []const u8) void {796    const parsed = std.json.parseFromSlice(std.json.Value, gpa, json, .{}) catch return;797    defer parsed.deinit();798    if (parsed.value != .object) return;799    const elements = parsed.value.object.get("elements") orelse return;800    switch (elements) {801        .object => |obj| {802            var it = obj.iterator();803            while (it.next()) |entry| {804                const ver = if (firstStorePath(entry.value_ptr.*)) |p| pkgFromStorePath(p).version else "";805                output.listPkg(entry.key_ptr.*, ver);806            }807        },808        .array => |arr| {809            for (arr.items) |el| {810                const path = firstStorePath(el) orelse continue;811                const row = pkgFromStorePath(path);812                output.listPkg(row.name, row.version);813            }814        },815        else => {},816    }817}818819pub fn tryCmd(ctx: Ctx) !void {820    const pkg_name_arg = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;821    const shell_pkg = types.NixPackage{ .attr = pkg_name_arg, .pname = pkg_name_arg, .version = "", .description = "" };822    try tryPkg(ctx, shell_pkg);823}824825// --- Service commands ---826827pub fn service(ctx: Ctx) !void {828    if (std.mem.eql(u8, ctx.sub, "list") or ctx.sub.len == 0) {829        output.serviceListHeader(ctx.machine.name);830        const svcs = exec.serviceList(ctx.gpa, ctx.io, &ctx.machine) catch &.{};831        defer ctx.gpa.free(svcs);832        for (svcs) |s| output.serviceRow(s);833        return;834    }835    if (std.mem.eql(u8, ctx.sub, "logs")) {836        const name = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;837        const follow = ctx.args.len > 1 and std.mem.eql(u8, ctx.args[1], "-f");838        output.serviceLogsHeader(name, ctx.last, ctx.machine.name);839        _ = try exec.serviceLogs(ctx.io, &ctx.machine, ctx.gpa, name, ctx.last, follow);840        return;841    }842    if (std.mem.eql(u8, ctx.sub, "status")) {843        const name = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;844        output.serviceVerb("status", name, ctx.machine.name);845        _ = try exec.serviceCtl(ctx.io, &ctx.machine, ctx.gpa, "status", name);846        return;847    }848    // start/stop/restart/enable/disable849    const name = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;850    if (ctx.cfg.confirm and (std.mem.eql(u8, ctx.sub, "stop") or std.mem.eql(u8, ctx.sub, "disable"))) {851        if (!output.confirm("")) return;852    }853    output.serviceVerb(ctx.sub, name, ctx.machine.name);854    _ = try exec.serviceCtl(ctx.io, &ctx.machine, ctx.gpa, ctx.sub, name);855    output.serviceDone();856}857858// --- Flake commands ---859860pub fn flake(ctx: Ctx) !void {861    if (std.mem.eql(u8, ctx.sub, "update")) {862        output.flakeUpdateStart();863        const input: ?[]const u8 = if (ctx.args.len > 0) ctx.args[0] else null;864        _ = try exec.flakeUpdate(ctx.io, &ctx.machine, ctx.gpa, input);865        output.flakeLockWritten();866        return;867    }868    if (std.mem.eql(u8, ctx.sub, "check")) {869        output.flakeCheckStart();870        const code = try exec.flakeCheck(ctx.io, &ctx.machine, ctx.gpa);871        if (code == 0) output.flakeValid() else output.checkFailed("");872        return;873    }874    if (std.mem.eql(u8, ctx.sub, "show")) {875        const json_out = exec.flakeShow(ctx.gpa, ctx.io, &ctx.machine) catch null;876        if (json_out) |j| {877            defer ctx.gpa.free(j);878            output.flakeShowHeader("flake outputs");879            // Parse and display the flake outputs880            const parsed = std.json.parseFromSlice(std.json.Value, ctx.gpa, j, .{}) catch return;881            defer parsed.deinit();882            if (parsed.value == .object) {883                var it = parsed.value.object.iterator();884                while (it.next()) |entry| {885                    if (entry.value_ptr.* == .object) {886                        var inner = entry.value_ptr.object.iterator();887                        while (inner.next()) |e2| {888                            const desc = if (e2.value_ptr.* == .object)889                                if (e2.value_ptr.object.get("description")) |d|890                                    if (d == .string) d.string else ""891                                else ""892                            else "";893                            output.flakeShowEntry(entry.key_ptr.*, e2.key_ptr.*, desc);894                        }895                    }896                }897            }898        }899        return;900    }901    if (std.mem.eql(u8, ctx.sub, "init")) {902        _ = try exec.flakeInit(ctx.io, &ctx.machine, ctx.gpa);903        return;904    }905    if (std.mem.eql(u8, ctx.sub, "lock")) {906        _ = try exec.flakeLock(ctx.io, &ctx.machine, ctx.gpa);907        return;908    }909    if (std.mem.eql(u8, ctx.sub, "clone")) {910        const url = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;911        _ = try exec.flakeClone(ctx.io, &ctx.machine, ctx.gpa, url);912        return;913    }914}915916// --- Store commands ---917918pub fn store(ctx: Ctx) !void {919    if (std.mem.eql(u8, ctx.sub, "gc")) {920        _ = try exec.storeGc(ctx.io, &ctx.machine, ctx.gpa);921        return;922    }923    if (std.mem.eql(u8, ctx.sub, "verify")) {924        output.storeVerifyStart();925        _ = try exec.storeVerify(ctx.io, &ctx.machine, ctx.gpa);926        return;927    }928    if (std.mem.eql(u8, ctx.sub, "repair")) {929        if (ctx.cfg.confirm and !output.confirm("")) return;930        output.storeRepairStart();931        _ = try exec.storeRepair(ctx.io, &ctx.machine, ctx.gpa);932        return;933    }934    if (std.mem.eql(u8, ctx.sub, "info")) {935        const si = try exec.storeInfo(ctx.gpa, ctx.io, &ctx.machine);936        output.storeInfo(si);937        return;938    }939    if (std.mem.eql(u8, ctx.sub, "path")) {940        const attr = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;941        const path = try exec.storePath(ctx.gpa, ctx.io, &ctx.machine, attr);942        defer ctx.gpa.free(path);943        output.storePath(path);944        return;945    }946    // default: info947    const si = try exec.storeInfo(ctx.gpa, ctx.io, &ctx.machine);948    output.storeInfo(si);949}950951// --- Channel commands ---952953pub fn channel(ctx: Ctx) !void {954    if (std.mem.eql(u8, ctx.sub, "list") or ctx.sub.len == 0) {955        output.channelListHeader(ctx.machine.name);956        const chans = try exec.channelList(ctx.gpa, ctx.io, &ctx.machine);957        defer ctx.gpa.free(chans);958        for (chans) |ch| output.channelRow(ch);959        return;960    }961    if (std.mem.eql(u8, ctx.sub, "add")) {962        const url = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;963        const name = if (ctx.args.len > 1) ctx.args[1] else "";964        _ = try exec.channelAdd(ctx.io, &ctx.machine, ctx.gpa, url, name);965        output.channelDone();966        return;967    }968    if (std.mem.eql(u8, ctx.sub, "remove")) {969        const name = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;970        _ = try exec.channelRemove(ctx.io, &ctx.machine, ctx.gpa, name);971        output.channelDone();972        return;973    }974    if (std.mem.eql(u8, ctx.sub, "update")) {975        return channelUpdateCmd(ctx);976    }977}978979// --- Profile commands ---980981pub fn profile(ctx: Ctx) !void {982    if (std.mem.eql(u8, ctx.sub, "list") or ctx.sub.len == 0) {983        output.profileListHeader();984        const out = exec.profileList(ctx.gpa, ctx.io, &ctx.machine) catch null;985        if (out) |o| {986            defer ctx.gpa.free(o);987            var lines = std.mem.splitScalar(u8, o, '\n');988            while (lines.next()) |line| {989                const t = std.mem.trim(u8, line, " \t\r");990                if (t.len == 0) continue;991                output.profileRow(t, "", "");992            }993        }994        return;995    }996    if (std.mem.eql(u8, ctx.sub, "install")) {997        const attr = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;998        _ = try exec.profileInstall(ctx.io, &ctx.machine, ctx.gpa, attr);999        output.done();1000        return;1001    }1002    if (std.mem.eql(u8, ctx.sub, "remove")) {1003        const attr = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;1004        _ = try exec.profileRemove(ctx.io, &ctx.machine, ctx.gpa, attr);1005        output.done();1006        return;1007    }1008    if (std.mem.eql(u8, ctx.sub, "upgrade")) {1009        _ = try exec.profileUpgrade(ctx.io, &ctx.machine, ctx.gpa);1010        output.done();1011        return;1012    }1013}10141015// --- Pkg commands ---10161017pub fn pkg(ctx: Ctx) !void {1018    const name = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;1019    if (std.mem.eql(u8, ctx.sub, "why")) {1020        _ = try exec.pkgWhy(ctx.io, &ctx.machine, ctx.gpa, name);1021        return;1022    }1023    if (std.mem.eql(u8, ctx.sub, "deps")) {1024        _ = try exec.pkgDeps(ctx.io, &ctx.machine, ctx.gpa, name);1025        return;1026    }1027    if (std.mem.eql(u8, ctx.sub, "size")) {1028        const s = exec.pkgSize(ctx.gpa, ctx.io, &ctx.machine, name) catch null;1029        if (s) |sz| {1030            defer ctx.gpa.free(sz);1031            output.pkgResult("size", sz);1032        }1033        return;1034    }1035    if (std.mem.eql(u8, ctx.sub, "path")) {1036        const p = try exec.storePath(ctx.gpa, ctx.io, &ctx.machine, name);1037        defer ctx.gpa.free(p);1038        output.pkgResult("path", p);1039        return;1040    }1041    if (std.mem.eql(u8, ctx.sub, "closure")) {1042        _ = try exec.pkgClosure(ctx.io, &ctx.machine, ctx.gpa, name);1043        return;1044    }1045}10461047// --- Pin / Unpin ---10481049pub fn pin(ctx: Ctx) !void {1050    const input = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;1051    const commit = if (ctx.args.len > 1) ctx.args[1] else return error.Internal;1052    exec.editFlakeLock(ctx.gpa, input, commit) catch return error.ProcessFailed;1053    output.pinDone(input, commit);1054}10551056pub fn unpin(ctx: Ctx) !void {1057    const input = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;1058    _ = try exec.flakeUpdate(ctx.io, &ctx.machine, ctx.gpa, input);1059    output.unpinDone(input);1060}10611062// --- Hash / Fetch ---10631064pub fn hash(ctx: Ctx) !void {1065    const path = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;1066    const h = try exec.nixHash(ctx.gpa, ctx.io, &ctx.machine, path);1067    defer ctx.gpa.free(h);1068    output.hashResult(std.mem.trim(u8, h, " \t\n\r"));1069}10701071pub fn fetch(ctx: Ctx) !void {1072    const url = if (ctx.args.len > 0) ctx.args[0] else return error.Internal;1073    const h = try exec.nixFetch(ctx.gpa, ctx.io, &ctx.machine, url);1074    defer ctx.gpa.free(h);1075    output.fetchResult(std.mem.trim(u8, h, " \t\n\r"), url);1076}10771078// --- Build / Run ---10791080pub fn build(ctx: Ctx) !void {1081    const attr: ?[]const u8 = if (ctx.args.len > 0) ctx.args[0] else null;1082    output.buildStart(attr orelse "default");1083    const code = try exec.nixBuild(ctx.io, &ctx.machine, ctx.gpa, attr);1084    if (code != 0) return error.BuildFailed;1085    output.buildDone();1086}10871088pub fn runCmd(ctx: Ctx) !void {1089    const pkg_arg = if (ctx.args.len > 0) ctx.args[0] else return error.PackageNotFound;1090    output.runStart(pkg_arg);1091    _ = try exec.nixRun(ctx.io, &ctx.machine, ctx.gpa, pkg_arg);1092}10931094// --- Hello ---10951096pub fn hello(ctx: Ctx) !void {1097    output.hello(ctx.cfg.machines);1098}10991100// Runs when ~/.nina.conf is absent on first invocation (interactive TTY only).1101// Prompts for machine name, config path, and local flag, then writes the file.1102pub fn firstRunWizard(gpa: std.mem.Allocator, io: std.Io, environ: *const std.process.Environ.Map) !void {1103    const home = environ.get("HOME") orelse {1104        errors.error_info.setSuggestion("set HOME environment variable", .{});1105        return error.ConfigNotFound;1106    };11071108    output.firstRunBanner();1109    output.firstRunNoConfig();11101111    var name_buf: [256]u8 = undefined;1112    var path_buf: [256]u8 = undefined;1113    var local_buf: [256]u8 = undefined;11141115    const machine_name = output.firstRunPrompt("machine name", "my-machine", &name_buf);1116    const config_path = output.firstRunPrompt("config path", "/etc/nixos", &path_buf);1117    const local_str = output.firstRunPrompt("local", "true", &local_buf);11181119    const conf_path = try std.fmt.allocPrint(gpa, "{s}/.nina.conf", .{home});1120    defer gpa.free(conf_path);11211122    var content_buf: [1024]u8 = undefined;1123    const content = try std.fmt.bufPrint(&content_buf,1124        \\[machine]1125        \\name = {s}1126        \\config = {s}1127        \\local = {s}1128        \\1129    , .{ machine_name, config_path, local_str });11301131    const file = std.Io.Dir.createFile(.cwd(), io, conf_path, .{}) catch {1132        errors.error_info.setMessage("could not write {s}", .{conf_path});1133        return error.Internal;1134    };1135    defer file.close(io);1136    file.writePositionalAll(io, content, 0) catch {1137        errors.error_info.setMessage("could not write {s}", .{conf_path});1138        return error.Internal;1139    };11401141    output.firstRunWritten(conf_path);1142}11431144pub fn setup(gpa: std.mem.Allocator, io: std.Io, environ: *const std.process.Environ.Map) !void {1145    // Create ~/.nina.conf first if it doesn't exist. This makes `nina setup`1146    // a complete onboarding command — not just a nix-features check.1147    if (environ.get("HOME")) |home| {1148        var path_buf: [512]u8 = undefined;1149        if (std.fmt.bufPrint(&path_buf, "{s}/.nina.conf", .{home})) |conf_path| {1150            if (std.Io.Dir.openFile(.cwd(), io, conf_path, .{})) |f| {1151                f.close(io);1152            } else |_| {1153                try firstRunWizard(gpa, io, environ);1154                errors.error_info.reset();1155            }1156        } else |_| {}1157    }11581159    output.setupCheck();1160    const status = exec.checkNixFeatures(gpa, io, environ);1161    output.setupFeatures(status.nix_command, status.flakes);11621163    if (status.allEnabled()) {1164        output.setupAllSet();1165        api.ensureRegistryPinned(gpa, io, environ);1166        return;1167    }11681169    // On NixOS the features belong in configuration.nix (the declarative,1170    // permanent home), not ~/.config/nix/nix.conf. Offer to add the one line;1171    // the user runs the rebuild. We don't pin the registry here because the1172    // features aren't live until that rebuild lands.1173    if (exec.isNixOS(io)) {1174        const conf_path = "/etc/nixos/configuration.nix";1175        if (exec.nixosConfigEnablesFeatures(gpa, io, conf_path)) {1176            output.setupNixosNeedsRebuild(conf_path);1177            return;1178        }1179        output.setupNixosOffer(exec.NIXOS_FEATURES_LINE, conf_path);1180        if (output.confirmDefaultNo("add it now?")) {1181            if (exec.appendFeaturesToNixosConfig(gpa, io, environ, conf_path)) |_| {1182                output.setupNixosWrote(conf_path);1183            } else |_| {1184                output.setupNixosManual(exec.NIXOS_FEATURES_LINE, conf_path);1185            }1186        } else {1187            output.setupNixosManual(exec.NIXOS_FEATURES_LINE, conf_path);1188        }1189        return;1190    }11911192    // Non-NixOS: a user-level nix.conf takes effect immediately, no sudo needed.1193    output.setupEnabling();1194    const path = try exec.enableNixFeatures(gpa, io, environ);1195    defer gpa.free(path);11961197    output.setupDone(path);1198    api.ensureRegistryPinned(gpa, io, environ);1199}12001201// --- Log helper ---12021203fn logAction(ctx: Ctx, action: []const u8, gen: u32) void {1204    var ts_buf: [32]u8 = undefined;1205    const ts = nowIso(ctx.io, &ts_buf);1206    var buf: [256]u8 = undefined;1207    const entry = std.fmt.bufPrint(&buf, "{{\"ts\":\"{s}\",\"machine\":\"{s}\",\"command\":\"{s}\",\"outcome\":\"success\",\"gen_before\":null,\"gen_after\":{d},\"duration_ms\":0}}\n", .{1208        ts, ctx.machine.name, action, gen,1209    }) catch return;1210    exec.appendNinaLog(ctx.io, ctx.environ, entry);1211}12121213// Wall-clock UTC as ISO-8601. Uses Io.Clock.real (the settable Unix-epoch clock);1214// Io.Clock.awake is monotonic and unsuitable for timestamps. Falls back to epoch 0.1215fn nowIso(io: std.Io, buf: []u8) []const u8 {1216    const fallback = "1970-01-01T00:00:00Z";1217    const ns = std.Io.Clock.real.now(io).toNanoseconds();1218    if (ns <= 0) return fallback;1219    const secs: u64 = @intCast(@divFloor(ns, 1_000_000_000));1220    const es = std.time.epoch.EpochSeconds{ .secs = secs };1221    const ed = es.getEpochDay();1222    const yd = ed.calculateYearDay();1223    const md = yd.calculateMonthDay();1224    const ds = es.getDaySeconds();1225    return std.fmt.bufPrint(buf, "{d:0>4}-{d:0>2}-{d:0>2}T{d:0>2}:{d:0>2}:{d:0>2}Z", .{1226        yd.year, md.month.numeric(), @as(u32, md.day_index) + 1,1227        ds.getHoursIntoDay(), ds.getMinutesIntoHour(), ds.getSecondsIntoMinute(),1228    }) catch return fallback;1229}