update to latest zig@master

build.zig.zon

···
     .version = "0.0.1",
     .dependencies = .{
         .known_folders = .{
-            .url = "git+https://github.com/ziglibs/known-folders.git#bafef170a73c064dc706fcfbdc2e406a35681a9c",
-            .hash = "known_folders-0.0.0-Fy-PJovNAAAtqbaXgBhV6G-Z4-WNo7P0Rov-x-npZq21",
+            .url = "git+https://github.com/ziglibs/known-folders.git?ref=master#8465ba6cfc49fe941f95c75b3ae48c03aa6125b5",
+            .hash = "known_folders-0.0.0-Fy-PJqrJAACSvJM3Ux3aJi3wu5hOUYBRvcTM-9NTelui",
         },
     },
     .minimum_zig_version = "0.16.0-dev.1246+4b593a6c2",

src/agent/config.zig

···
         .account = "Bearer <TOKEN>",
         .agent = "Bearer <TOKEN>",
     },
+
+    pub fn updateAgentToken(self: *Config, token: []const u8) void {
+        self.auth.agent = "Bearer " ++ token;
+    }
 };
 
 const log = std.log.scoped(.agent);
 
-pub fn load(io: std.Io, allocator: std.mem.Allocator) !Config {
+pub fn load(io: std.Io, allocator: std.mem.Allocator, environ: *std.process.Environ.Map) !Config {
     log.debug("Loading config", .{});
 
-    const dir = try kf.open(io, allocator, .roaming_configuration, .{ .follow_symlinks = true }) orelse return error.NoConfigFolder;
+    const dir = try kf.open(
+        io,
+        allocator,
+        environ.*,
+        .roaming_configuration,
+        .{ .follow_symlinks = true },
+    ) orelse return error.NoConfigFolder;
     var file: ?std.Io.File = null;
     defer if (file) |f| f.close(io);
 
-    _ = dir.statPath(io, "space/config.zon", .{ .follow_symlinks = true }) catch {
+    _ = dir.statFile(io, "space/config.zon", .{ .follow_symlinks = true }) catch {
         file = try create(io, dir);
     };
 
···
     log.warn("Creating new config file", .{});
     const config = Config{};
 
-    try dir.makePath(io, "space");
+    try dir.createDirPath(io, "space");
     const file = try dir.createFile(io, "space/config.zon", .{ .read = true });
-    const file_old = std.fs.File.adaptFromNewApi(file);
 
     var buffer: [64]u8 = undefined;
-    var writer = file_old.writer(&buffer);
+    var writer = file.writer(io, &buffer);
 
     try std.zon.stringify.serializeArbitraryDepth(config, .{}, &writer.interface);
     try writer.interface.flush();

src/main.zig

···
     // _ = io;
     // _ = client;
 
-    var fleet_f = try api.fleet.listShips(client, .{});
-    defer _ = fleet_f.cancel(io) catch {};
+    var register_f = try api.agent.register(client, "ALTAGOS", .ANCIENTS);
+    defer _ = register_f.cancel(io) catch {};
+
+    const register = try register_f.await(io);
+    defer register.deinit();
+
+    std.log.info("Registered agent\n{f}", .{pretty(register.value)});
 
-    const fleet = try fleet_f.await(io);
-    defer fleet.deinit();
+    // var fleet_f = try api.fleet.listShips(client, .{});
+    // defer _ = fleet_f.cancel(io) catch {};
 
-    std.log.info("{f}", .{pretty(fleet.value)});
+    // const fleet = try fleet_f.await(io);
+    // defer fleet.deinit();
+
+    // std.log.info("{f}", .{pretty(fleet.value)});
 }
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
 
-    var io_impl: std.Io.Threaded = .init(allocator);
+    var io_impl: std.Io.Threaded = .init(allocator, .{
+        .environ = init.minimal.environ,
+    });
     defer io_impl.deinit();
     const io = io_impl.io();
 
     std.log.debug("Io threads: {}", .{io_impl.concurrent_limit.toInt() orelse 0});
 
-    const config = try agent.config.load(io, allocator);
+    const config = try agent.config.load(io, allocator, init.environ_map);
     defer agent.config.free(allocator, config);
 
     var client = Client.init(allocator, io, .{

src/meta/fmt.zig

···
 
 pub fn Pretty(comptime T: type) type {
     const global = struct {
-        var conf: ?std.Io.tty.Config = null;
+        var conf: ?std.Io.Terminal = null;
     };
     return struct {
         value: T,
···
         }
         pub fn format(this: *const @This(), w: *std.Io.Writer) error{WriteFailed}!void {
             if (global.conf == null) {
-                global.conf = .detect(.stderr());
+                var buffer: [64]u8 = undefined;
+                const stderr = std.debug.lockStderr(&buffer).terminal();
+                global.conf = stderr;
+                global.conf.?.writer = w;
+                std.debug.unlockStderr();
             }
-            return innerFmt(w, global.conf.?, T, this.value, false, .{}, .{});
+            std.log.debug("", .{});
+            return innerFmt(w, global.conf.?, T, this.value, !@inComptime(), .{}, .{});
         }
     };
 }
···
 };
 
 fn setColor(
-    w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     color: Color,
 ) void {
     switch (color) {
         .dim => {
-            tty.setColor(w, .dim) catch {};
+            tty.setColor(.dim) catch {};
         },
         .reset => {
-            tty.setColor(w, .reset) catch {};
+            tty.setColor(.reset) catch {};
         },
         .text => {
-            // tty.setColor(w, .italic) catch {};
-            tty.setColor(w, .dim) catch {};
-            tty.setColor(w, .blue) catch {};
+            // tty.setColor(.italic) catch {};
+            tty.setColor(.dim) catch {};
+            tty.setColor(.blue) catch {};
         },
         .field => {
-            tty.setColor(w, .green) catch {};
+            tty.setColor(.green) catch {};
         },
         .value => {
-            // tty.setColor(w, .italic) catch {};
-            tty.setColor(w, .blue) catch {};
+            // tty.setColor(.italic) catch {};
+            tty.setColor(.blue) catch {};
         },
     }
 }
 
 fn innerFmt(
     w: *std.Io.Writer,
-    tty: std.Io.tty.Config,
+    tty: std.Io.Terminal,
     comptime T: type,
     value: T,
     comptime runtime: bool,
···
         .array => |array| try printArray(w, tty, array, value, runtime, ctx, opts),
         .@"struct" => |str| try printStruct(T, w, tty, str, value, runtime, ctx, opts),
         else => {
-            tty.setColor(w, .red) catch {};
+            tty.setColor(.red) catch {};
             try w.print("Unimplemented! ({})", .{info});
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
         },
     }
 }
 
 fn printBool(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     value: bool,
     opts: Options,
 ) !void {
     if (opts.type_name) {
-        setColor(w, tty, .dim);
+        setColor(tty, .dim);
         try w.print("bool => ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     } else {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("=> ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
-    setColor(w, tty, .value);
+    setColor(tty, .value);
     if (value) {
-        tty.setColor(w, .bright_green) catch {};
+        tty.setColor(.bright_green) catch {};
     } else {
-        tty.setColor(w, .bright_red) catch {};
+        tty.setColor(.bright_red) catch {};
     }
     try w.print("{}", .{value});
-    setColor(w, tty, .reset);
+    setColor(tty, .reset);
 }
 
 fn printInt(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     int: Type.Int,
     value: anytype,
     opts: Options,
 ) !void {
     if (opts.type_name) {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("{s}{} => ", .{ if (int.signedness == .signed) "i" else "u", int.bits });
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     } else {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("=> ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
-    setColor(w, tty, .value);
+    setColor(tty, .value);
     try w.print("{}", .{value});
-    setColor(w, tty, .reset);
+    setColor(tty, .reset);
 }
 
 fn printFloat(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     float: Type.Float,
     value: anytype,
     opts: Options,
 ) !void {
     if (opts.type_name) {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("f{} => ", .{float.bits});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     } else {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("=> ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
-    setColor(w, tty, .value);
+    setColor(tty, .value);
     try w.print("{}", .{value});
-    setColor(w, tty, .reset);
+    setColor(tty, .reset);
 }
 
 fn printEnum(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     value: anytype,
     opts: Options,
 ) !void {
     if (opts.type_name) {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("{s} => ", .{@typeName(@TypeOf(value))});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     } else {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("=> ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
-    setColor(w, tty, .value);
+    setColor(tty, .value);
     try w.print("{}", .{value});
-    setColor(w, tty, .reset);
+    setColor(tty, .reset);
 }
 
 fn printOptional(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     optional: Type.Optional,
     value: anytype,
     comptime runtime: bool,
···
     next_opts.last_layer_type_name = opts.type_name;
 
     if (opts.type_name) {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("?", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
 
     if (value) |val| {
         try innerFmt(w, tty, optional.child, val, runtime, ctx, next_opts);
     } else {
         if (opts.type_name) {
-            tty.setColor(w, .dim) catch {};
+            tty.setColor(.dim) catch {};
             try w.print("{s} => ", .{@typeName(optional.child)});
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
         } else {
-            tty.setColor(w, .dim) catch {};
+            tty.setColor(.dim) catch {};
             try w.print("=> ", .{});
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
         }
 
-        tty.setColor(w, .blue) catch {};
+        tty.setColor(.blue) catch {};
         try w.writeAll("null");
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
 }
 
 fn printArray(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     array: Type.Array,
     value: anytype,
     comptime runtime: bool,
···
     next_opts.last_layer_type_name = opts.type_name;
 
     if (opts.type_name) {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("[{}]{s} =>", .{ array.len, @typeName(array.child) });
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     } else {
-        tty.setColor(w, .dim) catch {};
+        tty.setColor(.dim) catch {};
         try w.print("=> ", .{});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
     }
 
     inline for (value, 0..) |item, idx| {
         try indent(w, runtime, ctx);
 
-        setColor(w, tty, .field);
+        setColor(tty, .field);
         try w.print("[{}] ", .{idx});
-        setColor(w, tty, .reset);
+        setColor(tty, .reset);
 
         next_ctx.indent_level = ctx.indent_level + 1;
         next_opts.type_name = false;
···
 
 fn printPointer(
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     ptr: Type.Pointer,
     value: anytype,
     comptime runtime: bool,
···
     switch (ptr.size) {
         .one => {
             if (opts.type_name) {
-                tty.setColor(w, .dim) catch {};
+                tty.setColor(.dim) catch {};
                 try w.print("*{s}", .{if (ptr.is_const) "const " else ""});
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
             }
 
             if (ptr.child == anyopaque or @typeInfo(ptr.child) == .@"fn")
···
         },
         .slice => {
             if (opts.type_name) {
-                setColor(w, tty, .dim);
+                setColor(tty, .dim);
                 try w.print("[]{s}", .{if (ptr.is_const) "const " else ""});
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
             }
 
             if (ptr.child == u8) {
-                tty.setColor(w, .dim) catch {};
+                tty.setColor(.dim) catch {};
                 try w.print("{s}=>", .{if (opts.type_name) "u8 " else ""});
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
 
                 try indent(w, runtime, ctx);
 
-                setColor(w, tty, .text);
+                setColor(tty, .text);
                 try w.print("\"{s}\"", .{value});
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
                 return;
             }
 
-            setColor(w, tty, .dim);
+            setColor(tty, .dim);
             try w.print("{s}{s}", .{
                 if (opts.type_name) @typeName(ptr.child) else "",
                 if (opts.type_name) " =>" else "=>",
             });
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
 
             const run_ctx: Context(true) = .{ .indent_width = ctx.indent_width, .indent_level = ctx.indent_level };
             var next_ctx: Context(true) = .{ .indent_width = ctx.indent_width, .indent_level = ctx.indent_level };
···
             for (value, 0..) |item, idx| {
                 try indent(w, true, run_ctx);
 
-                setColor(w, tty, .field);
+                setColor(tty, .field);
                 try w.print("[{}] ", .{idx});
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
 
                 next_ctx.indent_level = ctx.indent_level + 1;
                 next_opts.type_name = false;
···
             }
 
             if (count == 0) {
-                setColor(w, tty, .dim);
+                setColor(tty, .dim);
                 try w.writeAll(" empty");
-                setColor(w, tty, .reset);
+                setColor(tty, .reset);
             }
         },
         else => {
···
 fn printStruct(
     comptime T: type,
     w: *Io.Writer,
-    tty: Io.tty.Config,
+    tty: Io.Terminal,
     str: Type.Struct,
     value: anytype,
     comptime runtime: bool,
···
     next_opts.type_name = if (!opts.type_name and !opts.last_layer_type_name) false else true;
     next_opts.last_layer_type_name = opts.type_name;
 
-    setColor(w, tty, .dim);
+    setColor(tty, .dim);
     if (opts.type_name) {
         try w.print("{s} =>", .{@typeName(T)});
     } else {
         try w.print("=>", .{});
     }
-    setColor(w, tty, .reset);
+    setColor(tty, .reset);
 
     if (runtime) {
         var next_ctx: Context(true) = ctx;
···
         inline for (str.fields) |field| {
             try indent(w, runtime, ctx);
 
-            setColor(w, tty, .field);
+            setColor(tty, .field);
             try w.print(".{s}", .{field.name});
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
 
-            setColor(w, tty, .dim);
+            setColor(tty, .dim);
             if (opts.type_name) {
                 try w.writeAll(": ");
             } else try w.writeByte(' ');
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
 
             next_ctx.indent_level = ctx.indent_level + 1;
 
···
         inline for (str.fields) |field| {
             try indent(w, runtime, ctx);
 
-            setColor(w, tty, .field);
+            setColor(tty, .field);
             try w.print(".{s}", .{field.name});
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
 
-            setColor(w, tty, .dim);
+            setColor(tty, .dim);
             if (opts.type_name) {
                 try w.writeAll(": ");
             } else try w.writeByte(' ');
-            setColor(w, tty, .reset);
+            setColor(tty, .reset);
 
             next_ctx.indent_level = ctx.indent_level + 1;
 

src/st/http.zig

···
 const log = std.log.scoped(.SpaceTraders);
 
 const Semaphore = struct {
-    mutex: Io.Mutex = .{ .state = .unlocked },
-    cond: Io.Condition = .{},
+    mutex: Io.Mutex = .init,
+    cond: Io.Condition = .init,
     /// It is OK to initialise this field to any value.
     permits: u64 = 0,
 
···
     duration: i64,
     time: ?Io.Timestamp,
 
-    mutex: Io.Mutex = .{ .state = .unlocked },
+    mutex: Io.Mutex = .init,
     semaphor: Semaphore,
 
     pub fn init(opts: struct { points: u54 = 2, duration: i64 = 1000 }) Limiter {