summaryrefslogtreecommitdiff
path: root/src/main.zig
blob: 7b6fd6d431ce9b9deb47c2a73612bb9ee56ef378 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
const std = @import("std");
const builtin = @import("builtin");
const pardes = @import("pardes.zig");
const ninep_io = @import("9p_io.zig");
const daemon = @import("daemon.zig");
const upgrade = @import("upgrade.zig");

pub const std_options_debug_threaded_io: ?*std.Io.Threaded = std.Io.Threaded.global_single_threaded;
pub const std_options_debug_io: std.Io = std_options_debug_threaded_io.?.io();

// Every thread's alternate signal stack is a threadlocal that libc zeroes as
// the thread starts, so std's 256 KiB made each 9P connection's thread cost
// that much resident. A stack-overflow segfault on a thread still printed its
// whole symbolized trace from 32 KiB up (16 KiB double-faulted): 64 KiB.
//
// FreeBSD answers a write to a terminal that is gone with ENXIO, an errno std
// does not expect: a Debug build traced it to stderr, that same terminal,
// and recursed until the stack ran out (a session whose ssh dropped hung).
pub const std_options: std.Options = .{
    .logFn = logFn,
    .signal_stack_size = 64 * 1024,
    .unexpected_error_tracing = (std.Options{}).unexpected_error_tracing and builtin.os.tag != .freebsd,
};

fn logFn(
    comptime level: std.log.Level,
    comptime scope: @EnumLiteral(),
    comptime format: []const u8,
    args: anytype,
) void {
    if (scope != .gui and std.c.getenv("PARDES_LOG") == null) return;
    std.log.defaultLog(level, scope, format, args);
}

pub const panic = std.debug.FullPanic(struct {
    fn call(msg: []const u8, ret_addr: ?usize) noreturn {
        if (!recovering.swap(true, .seq_cst)) {
            pardes.replica.dying();
            @import("vaxis").recover();
        }
        @import("crash.zig").record(msg);
        std.debug.defaultPanic(msg, ret_addr);
    }
}.call);

var recovering: std.atomic.Value(bool) = .init(false);

pub const debug = struct {
    pub fn handleSegfault(addr: ?usize, name: []const u8, opt_ctx: anytype) noreturn {
        if (!recovering.swap(true, .seq_cst)) {
            pardes.replica.dying();
            @import("vaxis").recover();
        }
        return std.debug.defaultHandleSegfault(addr, name, opt_ctx);
    }
};

const help_text =
    \\Usage: pardes [options] [file|dir|-]
    \\
    \\With no arguments the shell pane starts in tty mode. A FILE argument
    \\(optionally file:LINE) opens it alone, filling the window; a DIRECTORY
    \\argument becomes the cwd shells spawn in. `-` reads stdin into a +Pager
    \\pane, its colours kept and every other escape dropped:
    \\inside a pardes pane the outer session's, returning at once (a
    \\terminal's PAGER), else a new editor's.
    \\
    \\Options:
    \\  --tty                  start as one shell pane already in tty mode
    \\  -n <count>             initial shell panes: 1 (default) or 3 (classic).
    \\                         A FILE argument boots just that file instead.
    \\  --tty-toggle <key>     use Ctrl-<key> to toggle tty/editor mode
    \\  -l <dump>              load a dump of another instance (see Dump)
    \\  -w, --wait             inside a pardes pane, hand FILE to the outer
    \\                         session and return only once the pane it opened
    \\                         (or already had) is deleted: 0 then, 1 if the
    \\                         session goes away. For $EDITOR (acme's E):
    \\                         EDITOR='pardes --wait', which GIT_EDITOR follows.
    \\                         Outside pardes a session blocks anyway.
    \\  --nested               run a full session even inside another pardes.
    \\                         Without it, a pardes started inside a pardes
    \\                         hands its FILE argument to the outer one. This
    \\                         session will not serve its own children either.
    \\                         Explicit session configuration starts a new one.
    \\  --9p=<name>            name the default 9P socket. Without this flag,
    \\                         the name is the detached session name or pid.
    \\                         The socket is under $XDG_RUNTIME_DIR, falling
    \\                         back to ~/.local/state/pardes.
    \\  --9p-tcp=<dial>        also serve 9P at tcp!<numeric-ip>!<port>.
    \\  --mount=<name>=<dial>  mount a 9P session or Unix/TCP endpoint under /n/<name>.
    \\                         Repeat for more mounts; os and self are reserved.
    \\  --detach               run this session with no terminal (no window)
    \\                         until one attaches; its panes, shells and files
    \\                         stay. Detach, or a terminal that closes, leaves
    \\                         any session so. One `pardes --daemon` per user
    \\                         keeps them (PARDES_DAEMON=off: none)
    \\  --detach=<name>        ...named <name> rather than this process's pid,
    \\                         as --9p names it. One path component: no '/'
    \\                         and nothing empty
    \\  --attach               show the one detached session here (with
    \\                         none, the one session): in this terminal for
    \\                         `pardes`, a window for `pardes-gui`. One
    \\                         attached already, or of the other kind (a
    \\                         window's session in a terminal, or the
    \\                         reverse), is joined as a client, as
    \\                         --attach=<sock>:<name>. Returns when the
    \\                         session detaches or ends
    \\  --attach=<name>        ...the session called <name> (its --9p or
    \\                         --detach name, else its pid; see --ps)
    \\  --attach=<host>:<name> a client of session <name> on another machine,
    \\                         a terminal's or a window's (either kind's
    \\                         session), over `ssh -L` to its pardes-replica.sock
    \\                         ($PARDES_SSH: the ssh command, words, default
    \\                         `ssh`; and
    \\                         $PARDES_REMOTE_RUNTIME: its runtime directory,
    \\                         if not this one's path). Its keys show at once
    \\  --attach=<sock>:<name> ...through that socket (a path, with a '/'),
    \\                         one forwarded already, or this machine's
    \\  --ps                   what the pardes daemon keeps: each session (its
    \\                         pid, kind, whether attached), its clients and its
    \\                         shells, then the shells no session holds
    \\  --kill=<name>          end session <name> and its shells (TERM, then
    \\                         KILL 2 s later); unsaved changes are lost
    \\  --kill-all             end every session and every shell the daemon keeps
    \\  --geometry=WxH[+X+Y]   the window's size in points, and where it goes
    \\                         where the display lets a window say (X11)
    \\  -h, --help             show this help and exit
    \\  --version              print the version and exit
    \\
;

/// `pardes -` inside a session: `text`, stdin as it came, escapes and all,
/// into a new +Pager of the directory (/pager):
/// written after the directory on that one open, the session parses it
/// (pager.zig) and puts it in as one undo step, left clean. A text the
/// session would not take is never lost: it goes to stderr, a terminal,
/// with why, and the exit is 1.
fn pageInto(io: std.Io, gpa: std.mem.Allocator, dial: []const u8, text: []const u8) void {
    const Fail = struct {
        fn with(o: std.Io, t: []const u8, what: []const u8, err: anyerror) noreturn {
            var words_buf: [128]u8 = undefined;
            const why = if (err == error.Remote) ninep_io.Client.lastSaid() else forwardWords(err, &words_buf);
            var buf: [512]u8 = undefined;
            const head = std.fmt.bufPrint(&buf, "pardes: -: {s}: {s}; the text follows\n", .{ what, why }) catch "pardes: -: refused; the text follows\n";
            std.Io.File.stderr().writeStreamingAll(o, head) catch {};
            std.Io.File.stderr().writeStreamingAll(o, t) catch {};
            std.process.exit(1);
        }
    };
    // The pane's directory: this one, unless its name could not be one line
    // of a ctl (a newline, a control byte): then the session's.
    var cwd_buf: [4096]u8 = undefined;
    const cwd: []const u8 = cwd_buf[0 .. std.process.currentPath(io, &cwd_buf) catch 0];
    // ...or the session's when this one may not be written (`git log` in
    // /usr/src), which /pager refuses: the text is paged all the same.
    const plain = for (cwd) |c| {
        if (c < ' ' or c == 0x7f) break false;
    } else !pardes.filesystem.deniedAbove(cwd);
    var line_buf: [4200]u8 = undefined;
    const dir_line = std.fmt.bufPrint(&line_buf, "{s}\n", .{if (plain) cwd else ""}) catch "\n";
    // Its serial read back on the open that asked, once the text is in:
    // another client's exec meanwhile can never send it into that
    // client's pane.
    const answer = ninep_io.Client.ask(gpa, dial, "/pager", dir_line, text) catch |err| Fail.with(io, text, "no +Pager pane", err);
    _ = std.fmt.parseInt(u32, std.mem.trim(u8, answer, " \n"), 10) catch |err| Fail.with(io, text, "no +Pager pane", err);
}

/// Stdin to its end, as it came (its escapes are the session's to parse,
/// pager.zig), at most a file's limit, a longer one cut there and said so
/// at its end.
fn readStdinText(io: std.Io, gpa: std.mem.Allocator) ![]u8 {
    const limit = pardes.memory.limits.max_file_bytes;
    var raw: std.ArrayList(u8) = .empty;
    var chunk: [64 * 1024]u8 = undefined;
    var stdin = std.Io.File.stdin().readerStreaming(io, &chunk);
    // One byte past the limit says there is more.
    stdin.interface.appendRemaining(gpa, &raw, .limited(limit + 1)) catch |err| switch (err) {
        error.StreamTooLong => {
            raw.shrinkRetainingCapacity(limit);
            // CAN ends an escape the cut left half sent, and SGR 0 its colour,
            // so the note is never swallowed or tinted.
            const said = "\x18\x1b[m\n[pardes: the rest of stdin is cut: a pane holds at most a file's limit]\n";
            try raw.appendSlice(gpa, said);
        },
        else => |e| return e,
    };
    return raw.toOwnedSlice(gpa);
}

/// A forwarding failure in words, never an error's name: the ones this
/// file raises said outright, any other as its name's words (`NotFound`,
/// `not found`), a dial's as Messages says it.
fn forwardWords(err: anyerror, buf: []u8) []const u8 {
    return switch (err) {
        error.NotOneLine => "a file name is one line, and this one holds a newline",
        error.NotAFileName => "names a directory, not a file",
        error.NoWorkingDirectory => "this shell's working directory is gone",
        error.DirectoryNotWritable => "permission denied: its directory may not be read or written, so it could never be saved",
        error.NotAPaneAddress => "not a pane address: @p and a pane's number",
        error.NoSuchPane => "this session has no such pane",
        else => if (pardes.Messages.dialReason(err)) |why| why else words: {
            var n: usize = 0;
            for (@errorName(err), 0..) |c, i| {
                if (n + 2 > buf.len) break;
                if (std.ascii.isUpper(c) and i > 0) {
                    buf[n] = ' ';
                    n += 1;
                }
                buf[n] = std.ascii.toLower(c);
                n += 1;
            }
            break :words buf[0..n];
        },
    };
}

/// `--wait` after a forwarded look, as plan9port's E reads acme's log: the
/// pane `path` landed in (the one it already had, if open), then /log
/// followed on one connection until that pane's `del` -- exit 0 -- or the
/// connection ends with the session -- exit 1.
fn waitForDel(gpa: std.mem.Allocator, dial: []const u8, path: []const u8, known: ?u32) noreturn {
    // The pane this launch made (a name not there yet), or the one its
    // look answered, is known by its serial; one the look answered none
    // for is found by its file. Found by none after the look went there,
    // it was closed already: that is the end being waited for, not a
    // failure (a pane closed between the look and this read made `--wait`
    // exit 1 before).
    const serial = known orelse found: {
        const first = ninep_io.Client.read(gpa, dial, "/index", "/index") catch std.process.exit(1);
        defer gpa.free(first);
        break :found paneShowing(first, path) orelse std.process.exit(0);
    };
    const Wait = struct {
        gpa: std.mem.Allocator,
        dial: []const u8,
        serial: u32,
        /// Deleted between the look and the follow: /index, read once the
        /// follow stands, says so, and a `del` after it is followed.
        fn gone(w: *const @This()) bool {
            const index = ninep_io.Client.read(w.gpa, w.dial, "/index", "/index") catch return false;
            defer w.gpa.free(index);
            return !hasPane(index, w.serial);
        }
        fn deleted(w: *const @This(), bytes: []const u8) bool {
            return isDel(bytes, w.serial);
        }
    };
    const w: Wait = .{ .gpa = gpa, .dial = dial, .serial = serial };
    ninep_io.Client.follow(dial, "/log", "follow new", &w, Wait.gone, Wait.deleted) catch std.process.exit(1);
    std.process.exit(0);
}

/// Whether log records `bytes` hold `del <serial> ...`.
fn isDel(bytes: []const u8, serial: u32) bool {
    var records = std.mem.splitScalar(u8, bytes, '\n');
    while (records.next()) |rec| {
        if (!std.mem.startsWith(u8, rec, "del ")) continue;
        const word = rec[4 .. std.mem.indexOfScalarPos(u8, rec, 4, ' ') orelse rec.len];
        if ((std.fmt.parseInt(u32, word, 10) catch continue) == serial) return true;
    }
    return false;
}

/// The serial of /index's first row named `path` (`serial kind dirty name col`).
fn paneShowing(index: []const u8, path: []const u8) ?u32 {
    var rows = std.mem.splitScalar(u8, index, '\n');
    while (rows.next()) |row| {
        var words = std.mem.splitScalar(u8, row, ' ');
        const serial = std.fmt.parseInt(u32, words.first(), 10) catch continue;
        _ = words.next() orelse continue; // kind
        _ = words.next() orelse continue; // dirty
        const rest = words.rest();
        const end = std.mem.lastIndexOfScalar(u8, rest, ' ') orelse continue;
        if (std.mem.eql(u8, rest[0..end], path)) return serial;
    }
    return null;
}

fn hasPane(index: []const u8, serial: u32) bool {
    var rows = std.mem.splitScalar(u8, index, '\n');
    while (rows.next()) |row| {
        const first = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len];
        if ((std.fmt.parseInt(u32, first, 10) catch continue) == serial) return true;
    }
    return false;
}

test "--wait finds the pane /index names a file by, spaces and all, and sees it gone" {
    const index = "1 term 0 /home/u 1\n4 text 1 /tmp/a b.txt 2\n";
    try std.testing.expectEqual(@as(?u32, 4), paneShowing(index, "/tmp/a b.txt"));
    try std.testing.expectEqual(@as(?u32, null), paneShowing(index, "/tmp/a"));
    try std.testing.expect(hasPane(index, 4) and !hasPane(index, 2));
    try std.testing.expect(isDel("new 5 /x\ndel 4 /tmp/a b.txt\n", 4));
    try std.testing.expect(!isDel("del 41 /x\n", 4) and !isDel("undel 4\n", 4));
}

fn badArgs(io: std.Io, comptime fmt: []const u8, args: anytype) noreturn {
    die(io, fmt ++ "\nTry 'pardes --help'.", args);
}

/// `pardes: <words>` on stderr, and exit 1.
fn die(io: std.Io, comptime fmt: []const u8, args: anytype) noreturn {
    var buf: [8192]u8 = undefined;
    const line = std.fmt.bufPrint(&buf, "pardes: " ++ fmt ++ "\n", args) catch "pardes: refused\n";
    std.Io.File.stderr().writeStreamingAll(io, line) catch {};
    std.process.exit(1);
}

/// The second line is what a replica's build must share with its session's
/// (wire.zig `semantics`).
const version_text = upgrade.version_line ++ "\n" ++ std.fmt.comptimePrint("semantics {x:0>16}\n", .{@import("wire.zig").semantics});

const nested_text =
    \\pardes: this shell is already inside pardes, and a pardes inside a pardes
    \\is spicy. Name a file or a directory and the outer session opens it, or
    \\pass --nested if you really want a second one in here.
    \\
;

pub const main = nativeMain;

// glibc's struct termios is 60 bytes, Zig 0.17's std.c.termios the kernel's
// 44: libc's tcgetattr wrote 16 bytes past every Zig caller's (vaxis's
// makeRaw, the stub's, the GUI's), and a ReleaseSafe build trapped at its
// first terminal. These take libc's place in the process: the kernel's own
// ioctls, which read and write only the 36 bytes both layouts begin with
// (the flags, the line, the kernel's 19 cc), so a caller of either size
// stays within its struct.
comptime {
    if (builtin.os.tag == .linux and builtin.abi.isGnu()) {
        @export(&kernelTcgetattr, .{ .name = "tcgetattr" });
        @export(&kernelTcsetattr, .{ .name = "tcsetattr" });
    }
}

fn kernelTcgetattr(fd: c_int, t: *std.os.linux.termios) callconv(.c) c_int {
    return libcResult(std.os.linux.tcgetattr(fd, t));
}

fn kernelTcsetattr(fd: c_int, how: c_int, t: *const std.os.linux.termios) callconv(.c) c_int {
    return libcResult(std.os.linux.tcsetattr(fd, @fromBackingInt(@bitCast(how)), t));
}

fn libcResult(rc: usize) c_int {
    const e = std.os.linux.errno(rc);
    if (e == .SUCCESS) return 0;
    std.c._errno().* = @intCast(@backingInt(e));
    return -1;
}

test "tcgetattr writes nothing past a Zig termios" {
    if (comptime !(builtin.os.tag == .linux and builtin.abi.isGnu())) return error.SkipZigTest;
    const master = std.c.open("/dev/ptmx", .{ .ACCMODE = .RDWR, .NOCTTY = true, .CLOEXEC = true }, @as(std.c.mode_t, 0));
    if (master < 0) return error.SkipZigTest;
    defer _ = std.c.close(master);
    var s: extern struct { t: std.c.termios, canary: [32]u8 } = .{ .t = undefined, .canary = @splat(0xAA) };
    try std.testing.expectEqual(0, std.c.tcgetattr(master, &s.t));
    try std.testing.expectEqualSlices(u8, &@as([32]u8, @splat(0xAA)), &s.canary);
    try std.testing.expectEqual(0, std.c.tcsetattr(master, .NOW, &s.t));
    try std.testing.expectEqual(-1, std.c.tcgetattr(-1, &s.t));
}

// init.gpa, what the tui, gui and detached shells allocate from, is their
// own fixed arena (memory.host) in a release build, spilling to libc's
// malloc, and std.start's DebugAllocator in Debug. Zig 0.17's std.start
// gives a safe build a SafeAllocator over the page allocator instead.
fn nativeMain(std_init: std.process.Init) !void {
    var init = std_init;
    if (builtin.mode != .debug) init.gpa = pardes.memory.host(std.heap.c_allocator);
    // A recorded session's tape replayed, no session of its own (src/tape.zig).
    if (init.environ_map.get("PARDES_REPLAY")) |tape| std.process.exit(pardes.tape.replayMain(init.io, tape));
    var stderr_probe: [64]u8 = undefined;
    _ = std.debug.lockStderr(&stderr_probe);
    std.debug.unlockStderr();

    var opts: pardes.Options = .{};
    var mounts: [pardes.filesystem.max_mounts]pardes.filesystem.Mount = undefined;
    var mounts_len: usize = 0;
    const arena = init.arena.allocator();
    const args = try init.minimal.args.toSlice(arena);
    // An addon's author's test (addon_test.zig): nothing else.
    if (args.len >= 3 and std.mem.eql(u8, args[1], "--addon-test"))
        std.process.exit(@import("addon_test.zig").main(init.io, init.gpa, args[2], if (args.len > 3) args[3] else null));
    // The per-user daemon a session started (daemon.zig), or an upgrade of
    // one with its registry: nothing else.
    if (comptime daemon.supported) if (args.len >= 2 and args.len <= 3 and std.mem.eql(u8, args[1], "--daemon"))
        daemon.serve(if (args.len == 3 and std.mem.startsWith(u8, args[2], upgrade.flag)) args[2][upgrade.flag.len..] else null);
    // An upgraded session's new process (upgrade.zig): its record, then the
    // arguments it was started with, which configure it as before; its
    // file, stdin, directory and daemon come from the record instead.
    const upgraded = comptime upgrade.supported and (pardes.platform == .tui or pardes.platform == .gui);
    if (upgraded) if (args.len > 1 and std.mem.startsWith(u8, args[1], upgrade.flag)) {
        upgrade.resumed = upgrade.Record.decode(args[1][upgrade.flag.len..]) catch badArgs(init.io, "--upgraded: a record this build cannot read", .{});
    };
    const resuming = upgrade.resumed != null;
    var session_only = true;
    var new_session = false;
    var explicit_tty = false;
    var detach: ?[]const u8 = null;
    var attach: ?[]const u8 = null;
    var positional: ?[:0]const u8 = null;
    var wait = false;
    var i: usize = if (resuming) 2 else 1;
    while (i < args.len) : (i += 1) {
        const a = args[i];
        const Flag = enum { @"--tty", @"-n", @"-l", @"--9p", @"--9p-tcp", @"--nested", @"-w", @"--wait", @"--detach", @"--attach", @"--ps", @"--kill-all", @"-h", @"--help", @"--version", @"--" };
        if (std.meta.stringToEnum(Flag, a)) |flag| switch (flag) {
            .@"--tty" => explicit_tty = true,
            .@"-n" => {
                session_only = false;
                new_session = true;
                i += 1;
                if (i >= args.len) badArgs(init.io, "-n needs a count after it: 1 or 3", .{});
                opts.shells = std.fmt.parseInt(u8, args[i], 10) catch
                    badArgs(init.io, "-n takes 1 or 3, not '{s}'", .{args[i]});
            },
            .@"-l" => {
                session_only = false;
                new_session = true;
                i += 1;
                if (i >= args.len) badArgs(init.io, "-l needs the path of a dump to load", .{});
                opts.load_path = args[i];
            },
            .@"--9p" => badArgs(init.io, "--9p needs a socket name: --9p=<name>", .{}),
            .@"--9p-tcp" => badArgs(init.io, "--9p-tcp needs tcp!<numeric-ip>!<port>", .{}),
            .@"--nested" => opts.nested = true,
            .@"-w", .@"--wait" => wait = true,
            .@"--detach" => detach = "",
            .@"--attach" => attach = "",
            .@"--ps" => manage(init.io, .list, ""),
            .@"--kill-all" => manage(init.io, .killall, ""),
            .@"-h", .@"--help" => return std.Io.File.stdout().writeStreamingAll(init.io, help_text),
            .@"--version" => return std.Io.File.stdout().writeStreamingAll(init.io, version_text),
            .@"--" => {
                // The end of options: what follows is a name, `-dash.txt` too.
                for (args[i + 1 ..]) |name| {
                    if (name.len == 0) badArgs(init.io, "an empty argument names nothing", .{});
                    if (positional != null) badArgs(init.io, "one file or directory at a time, and '{s}' is the second", .{name});
                    session_only = false;
                    positional = name;
                }
                break;
            },
        } else if (std.mem.eql(u8, a, "--tty-toggle") or std.mem.startsWith(u8, a, "--tty-toggle=")) {
            session_only = false;
            new_session = true;
            const key = if (a.len > "--tty-toggle".len) a["--tty-toggle=".len..] else next: {
                i += 1;
                if (i >= args.len) badArgs(init.io, "--tty-toggle needs a letter after it", .{});
                break :next args[i];
            };
            opts.tty_toggle = parseCtrlKey(key) orelse badArgs(init.io, "--tty-toggle wants one letter, not '{s}'", .{key});
        } else if (std.mem.startsWith(u8, a, "--9p=")) {
            new_session = true;
            const name = a["--9p=".len..];
            if (name.len == 0 or std.mem.indexOfAny(u8, name, "/\x00") != null)
                badArgs(init.io, "invalid 9P socket name: '{s}'", .{name});
            opts.ninep_name = name;
        } else if (std.mem.startsWith(u8, a, "--9p-tcp=")) {
            new_session = true;
            const dial = a["--9p-tcp=".len..];
            if (!std.mem.startsWith(u8, dial, "tcp!"))
                badArgs(init.io, "--9p-tcp needs tcp!<numeric-ip>!<port>", .{});
            _ = @import("9p_io.zig").networkAddress(dial, true) catch
                badArgs(init.io, "--9p-tcp needs tcp!<numeric-ip>!<port>", .{});
            if (opts.ninep_tcp != null) badArgs(init.io, "--9p-tcp was specified twice", .{});
            opts.ninep_tcp = dial;
        } else if (std.mem.startsWith(u8, a, "--mount=")) {
            new_session = true;
            const mount = a["--mount=".len..];
            const split = std.mem.indexOfScalar(u8, mount, '=') orelse
                badArgs(init.io, "--mount needs name=dial", .{});
            const name = mount[0..split];
            const dial = mount[split + 1 ..];
            if (dial.len == 0 or !@import("fs.zig").validMountName(name))
                badArgs(init.io, "invalid mount name or dial: '{s}'", .{mount});
            @import("9p_io.zig").Client.validateDial(dial) catch
                badArgs(init.io, "invalid mount dial: '{s}'", .{dial});
            for (mounts[0..mounts_len]) |existing| if (std.mem.eql(u8, existing.name, name))
                badArgs(init.io, "duplicate mount name: '{s}'", .{name});
            if (mounts_len == mounts.len) badArgs(init.io, "too many mounts (maximum {d})", .{mounts.len});
            mounts[mounts_len] = .{ .name = name, .dial = dial };
            mounts_len += 1;
        } else if (std.mem.startsWith(u8, a, "--geometry=")) {
            opts.geometry = a["--geometry=".len..];
        } else if (std.mem.startsWith(u8, a, "--detach=")) {
            detach = a["--detach=".len..];
        } else if (std.mem.startsWith(u8, a, "--attach=")) {
            attach = a["--attach=".len..];
        } else if (std.mem.startsWith(u8, a, "--kill=")) {
            const name = a["--kill=".len..];
            if (name.len == 0) badArgs(init.io, "--kill needs a session's name; --kill-all ends every one", .{});
            manage(init.io, .kill, name);
        } else if (a.len > 0 and (a[0] != '-' or std.mem.eql(u8, a, "-")) and positional == null) {
            // `-` is stdin, as for cat and vim: a text to show.
            session_only = false;
            positional = a;
        } else if (a.len == 0) {
            badArgs(init.io, "an empty argument names nothing", .{});
        } else if (a[0] == '-') {
            badArgs(init.io, "no such option: {s}", .{a});
        } else {
            badArgs(init.io, "one file or directory at a time, and '{s}' is the second", .{a});
        }
    }
    opts.tty_only = explicit_tty or session_only;
    opts.mounts = mounts[0..mounts_len];
    // `zig build run-isolated` with nothing named: something to look at on
    // arrival, read out of the binary itself.
    if (pardes.isolated and positional == null) {
        session_only = false;
        positional = "src/pardes.zig";
    }
    if (detach != null and attach != null)
        badArgs(init.io, "--detach and --attach are opposites: one runs the session, the other joins one", .{});
    // --wait waits on the pane a FILE opens: with none there is nothing to
    // wait for (EDITOR=pardes --wait is given the file).
    if (wait and positional == null)
        badArgs(init.io, "--wait needs a FILE: it returns when that file's pane is closed", .{});
    if (opts.ninep_name.len != 0 and attach != null)
        badArgs(init.io, "--9p names a session's own socket, and --attach has none of its own", .{});
    if (opts.ninep_tcp != null and attach != null)
        badArgs(init.io, "--9p-tcp opens a session's own listener, and --attach has none of its own", .{});
    if (opts.mounts.len != 0 and attach != null)
        badArgs(init.io, "--mount configures a session's own core, and --attach has none of its own", .{});
    if (!new_session and !opts.nested and detach == null and attach == null and !resuming) forwarding: {
        // Am I inside a pardes at all? That is $PARDES_PID and nothing else —
        // one variable, exported by every session that means to take its
        // children's Looks, so a session that could not open a socket is still
        // recognisably the session this shell is inside. A pid naming no live
        // process is a shell that outlived its editor (a daemon started from a
        // pane, a stale environment carried into a new terminal), which is not
        // nested at all.
        // `--wait` with only $PARDES_9P (a script or agent that talks to a
        // session from outside its panes, EDITOR='pardes --wait') is asked
        // of that session too: what it waits on is a pane there.
        const outside = wait and std.c.getenv("PARDES_PID") == null and std.c.getenv("PARDES_9P") != null;
        if (!outside) {
            const owner = std.mem.span(std.c.getenv("PARDES_PID") orelse break :forwarding);
            const pid = std.fmt.parseInt(std.c.pid_t, owner, 10) catch break :forwarding;
            if (pid <= 0 or std.c.kill(pid, @fromBackingInt(@intCast(0))) != 0) break :forwarding;
        }

        // Can I reach it? That is the other two, and it is a separate answer.
        const Parent = struct { dial: []const u8, serial: u32 };
        const found: ?Parent = reaching: {
            const dial = std.mem.span(std.c.getenv("PARDES_9P") orelse break :reaching null);
            ninep_io.Client.validateDial(dial) catch break :reaching null;
            // No pane of its own (`outside`): the session's root look, 0.
            const pane_text = std.mem.span(std.c.getenv("PARDES_PANE") orelse if (outside) break :reaching .{ .dial = dial, .serial = 0 } else break :reaching null);
            for (pane_text) |byte| if (!std.ascii.isDigit(byte)) break :reaching null;
            const serial = std.fmt.parseInt(u32, pane_text, 10) catch break :reaching null;
            if (serial == 0) break :reaching null;
            break :reaching .{ .dial = dial, .serial = serial };
        };
        // A pid we cannot reach is a session that is not answering: the shell
        // says it is inside one, but there is nothing there to take the file.
        // Starting an ordinary editor is what this did before the pid existed
        // and is the more useful of the two answers -- refusing to start would
        // leave a stale environment variable able to lock someone out of their
        // own editor.
        const parent = found orelse break :forwarding;
        // Does it answer? One that answers takes the file or says why not,
        // as acme's B does: from here on never a nested editor, whose
        // screen would be drawn inside the pane that asked.
        ninep_io.Client.probe(arena, parent.dial) catch {
            // `--wait` is someone's EDITOR waiting on that session: a screen
            // of its own drawn in their terminal is no answer. Said, exit 1.
            if (wait) die(init.io, "--wait: the session at {s} does not answer; it is gone", .{parent.dial[0..@min(parent.dial.len, 4096)]});
            break :forwarding;
        };
        const Refuse = struct {
            fn with(io: std.Io, what: []const u8, err: anyerror) noreturn {
                var words_buf: [128]u8 = undefined;
                die(io, "{s}: {s}", .{ what[0..@min(what.len, 4096)], if (err == error.Remote) ninep_io.Client.lastSaid() else forwardWords(err, &words_buf) });
            }
        };
        // The pane's `look` file: one line, and the line is the clicked text
        // itself, which is what a right click in that pane would have been.
        var look_buf: [64]u8 = undefined;
        const look = if (parent.serial == 0) "/look" else try std.fmt.bufPrint(&look_buf, "/pane/{d}/look", .{parent.serial});
        // `pardes -`: stdin read to its end, a +Pager pane of the session
        // made of it (as acme's `B` has no stdin, through pane/new, a name
        // and the body), and back at once: the PAGER a pane's shell gets.
        if (positional) |word| if (std.mem.eql(u8, word, "-")) {
            const text = readStdinText(init.io, arena) catch |err| Refuse.with(init.io, "stdin", err);
            // Nothing paged: no pane, and done.
            if (text.len == 0) return;
            pageInto(init.io, arena, parent.dial, text);
            return;
        };
        // From outside the session's panes there is no pane to say it is
        // nested in: `--wait` with no file opens nothing there.
        if (parent.serial == 0 and positional == null) break :forwarding;
        const typed_word = positional orelse {
            var tag_buf: [64]u8 = undefined;
            const tag = try std.fmt.bufPrint(&tag_buf, "/pane/{d}/tag", .{parent.serial});
            const contents = ninep_io.Client.read(arena, parent.dial, tag, tag) catch |err| Refuse.with(init.io, tag, err);
            arena.free(contents);
            try std.Io.File.stderr().writeStreamingAll(init.io, nested_text);
            std.process.exit(1);
        };
        // Named as it was given, its newline shown `\n`, so the refusal says
        // which name and why once.
        if (std.mem.indexOfAny(u8, typed_word, "\r\n") != null) {
            var shown_buf: [4 * 4096]u8 = undefined;
            Refuse.with(init.io, pardes.ctlfs.events.shown(typed_word[0..@min(typed_word.len, 4096)], &shown_buf), error.NotOneLine);
        }
        // `pardes '~/x'`, quoted so the shell left it: home, as a look's.
        var home_buf: [4096]u8 = undefined;
        const word = pardes.filesystem.expandHome(typed_word, &home_buf);
        const target = @import("look.zig").parsePathLine(word);
        // `@pN[:addr]` addresses a pane of this session: one it has is
        // looked at, one it has not is refused, never a file of that name.
        if (std.mem.startsWith(u8, target.path, pardes.config.pane_addr)) {
            const digits = word[pardes.config.pane_addr.len .. std.mem.indexOfScalar(u8, word, ':') orelse word.len];
            const serial = std.fmt.parseInt(u32, digits, 10) catch Refuse.with(init.io, word, error.NotAPaneAddress);
            var name_buf: [64]u8 = undefined;
            const name = try std.fmt.bufPrint(&name_buf, "/pane/{d}/name", .{serial});
            const named = ninep_io.Client.read(arena, parent.dial, name, name) catch Refuse.with(init.io, word, error.NoSuchPane);
            arena.free(named);
            var command_buf: [4200]u8 = undefined;
            const command = std.fmt.bufPrint(&command_buf, "{s}\n", .{word}) catch |err| Refuse.with(init.io, word, err);
            ninep_io.Client.write(arena, parent.dial, look, command) catch |err| Refuse.with(init.io, word, err);
            return;
        }
        var realbuf: [4096]u8 = undefined;
        var newbuf: [4096]u8 = undefined;
        const found_path: ?[]const u8 = if (pardes.filesystem.isVirtual(target.path)) target.path else if (pardes.filesystem.resolveOs(target.path, &realbuf)) |r| r.path else null;
        const path = found_path orelse named: {
            // A name not there yet, as acme's B takes one: its directory
            // resolved and the name kept, a pane made for it that Save
            // creates the file from.
            const base = std.Io.Dir.path.basename(target.path);
            if (base.len == 0 or std.mem.eql(u8, base, ".") or std.mem.eql(u8, base, "..")) Refuse.with(init.io, word, error.NotAFileName);
            const dir = pardes.filesystem.resolveOs(std.Io.Dir.path.dirname(target.path) orelse ".", &realbuf) orelse {
                // Its directory not there either: the name made absolute as
                // written, and the pane's Save makes the directories.
                var cwd_buf: [4096]u8 = undefined;
                const cwd = cwd_buf[0 .. std.process.currentPath(init.io, &cwd_buf) catch Refuse.with(init.io, word, error.NoWorkingDirectory)];
                const absolute = std.Io.Dir.path.resolvePosix(arena, &.{ cwd, target.path }) catch |err| Refuse.with(init.io, word, err);
                // Missing because one above may not be searched or written:
                // its Save could never make it, so refused now.
                if (pardes.filesystem.deniedAbove(std.Io.Dir.path.dirname(absolute) orelse "/")) Refuse.with(init.io, word, error.DirectoryNotWritable);
                break :named absolute;
            };
            // A directory that is there but may not be read or written: a
            // pane for the name could only fail at its Save, so refused now.
            std.Io.Dir.cwd().access(init.io, dir.path, .{ .read = true, .write = true, .execute = true }) catch Refuse.with(init.io, word, error.DirectoryNotWritable);
            break :named std.fmt.bufPrint(&newbuf, "{s}/{s}", .{ std.mem.trimEnd(u8, dir.path, "/"), base }) catch |err| Refuse.with(init.io, word, err);
        };
        var made_serial: ?u32 = null;
        if (found_path != null) {
            var command_buf: [8192]u8 = undefined;
            const command = std.fmt.bufPrint(&command_buf, "{s}{s}\n", .{ path, word[target.path.len..] }) catch |err| Refuse.with(init.io, word, err);
            // The pane it went to, read on the open that asked (another
            // client's look meanwhile is not this one's): what --wait waits on.
            const went = ninep_io.Client.ask(arena, parent.dial, look, command, "") catch |err| Refuse.with(init.io, word, err);
            var rows = std.mem.tokenizeAny(u8, went, " \n");
            if (rows.next()) |row| made_serial = std.fmt.parseInt(u32, row, 10) catch null;
        } else {
            const made = ninep_io.Client.read(arena, parent.dial, "/pane/new", "/pane/new") catch |err| Refuse.with(init.io, word, err);
            const serial = std.fmt.parseInt(u32, std.mem.trim(u8, made, " \n"), 10) catch |err| Refuse.with(init.io, word, err);
            made_serial = serial;
            var name_buf: [64]u8 = undefined;
            const name = try std.fmt.bufPrint(&name_buf, "/pane/{d}/name", .{serial});
            var line_buf: [4200]u8 = undefined;
            const line = std.fmt.bufPrint(&line_buf, "{s}\n", .{path}) catch |err| Refuse.with(init.io, word, err);
            ninep_io.Client.write(arena, parent.dial, name, line) catch |err| {
                // The name refused: the pane made for it goes too, no
                // stray +New left behind.
                var ctl_buf: [64]u8 = undefined;
                const ctl = std.fmt.bufPrint(&ctl_buf, "/pane/{d}/ctl", .{serial}) catch unreachable;
                var why_buf: [256]u8 = undefined;
                const said = ninep_io.Client.lastSaid();
                const why = why_buf[0..@min(said.len, why_buf.len)];
                @memcpy(why, said[0..why.len]);
                ninep_io.Client.write(arena, parent.dial, ctl, "delete\n") catch {};
                if (err == error.Remote) die(init.io, "{s}: {s}", .{ word[0..@min(word.len, 4096)], why });
                Refuse.with(init.io, word, err);
            };
        }
        if (wait) waitForDel(arena, parent.dial, path, made_serial);
        return;
    }
    if (resuming) positional = null;
    // `pardes -` outside a session: an editor whose first pane holds stdin,
    // as `vim -` does; the terminal is /dev/tty, never stdin.
    if (positional) |a| if (std.mem.eql(u8, a, "-")) {
        opts.stdin_text = readStdinText(init.io, arena) catch |err| badArgs(init.io, "stdin: {s}", .{@errorName(err)});
        // Nothing paged: nothing to show.
        if (opts.stdin_text.?.len == 0) return;
        positional = null;
    };
    if (positional) |a| {
        const target = @import("look.zig").parsePathLine(a);
        if (std.mem.eql(u8, target.path, "/n") or std.mem.startsWith(u8, target.path, "/n/") or
            std.mem.eql(u8, target.path, "/virtual") or std.mem.startsWith(u8, target.path, "/virtual/"))
        {
            opts.file = try arena.dupe(u8, target.path);
            opts.file_line = target.at.line;
        } else if (std.meta.isError(std.process.setCurrentPath(init.io, a))) {
            var cwdbuf: [4096]u8 = undefined;
            const cwd = cwdbuf[0 .. std.process.currentPath(init.io, &cwdbuf) catch
                badArgs(init.io, "this shell's working directory is gone; cd somewhere that exists", .{})];
            var realbuf: [4096]u8 = undefined;
            switch (@import("look.zig").resolve(null, a, cwd, &realbuf)) {
                .file => |t| {
                    opts.file = try arena.dupe(u8, t.path);
                    opts.file_line = t.at.line;
                },
                .kind => |t| opts.file = try arena.dupe(u8, t.path),
                .none => opts.missing = .{
                    .word = try arena.dupe(u8, a),
                    .dir = try arena.dupe(u8, cwd),
                },
                .url => badArgs(init.io, "a URL is not something a launch can open; start pardes and click it", .{}),
                .pane => badArgs(init.io, "@pN addresses a pane of a running pardes, so there is none yet", .{}),
                else => badArgs(init.io, "cannot enter that directory: {s}", .{a}),
            }
        }
    }
    // The real bare-tty startup wants the editor half present from the first
    // frame, so it names that layout; a core booted for a test names none and
    // gets the raw shell by itself. This has to come AFTER the positional is
    // resolved: naming a layout short-circuits `Boot.of`, so choosing it any
    // earlier threw away a file argument, and the error pane for one that does
    // not exist, without a word.
    if (opts.tty_only and opts.file == null and opts.missing == null) opts.boot = .tty;
    const found = pardes.config.User.load(init.io, arena, init.environ_map);
    opts.startup_config = found.bytes;
    opts.startup_config_path = found.path;
    opts.config_dir = found.dir;
    opts.state = .disk;
    opts.recent_import = oldRecentDir(arena, init.environ_map);
    if (found.dir) |d| @import("crash.zig").setDir(d);
    if (attach) |name| if (std.mem.lastIndexOfScalar(u8, name, ':')) |colon| {
        remoteAttach(init, opts, name[0..colon], name[colon + 1 ..]);
    };
    if (attach) |name| if (!resuming) attachTo(init, opts, name);
    if (detach) |name| {
        // Said plainly, never a Zig error trace: a name a live session's
        // socket holds already (a plain session is named by its pid too).
        if (name.len != 0 and !resuming and ninep_io.taken(name)) die(init.io, "a session named {s} is already running", .{name});
        if (opts.ninep_name.len == 0) opts.ninep_name = name;
        // Nobody's size yet: one roomy enough for a script's panes; `size`
        // sets another, and an attached terminal or window its own.
        opts.cols = 160;
        opts.rows = 50;
    }
    const kind: daemon.Kind = if (pardes.platform == .gui) .gui else .tty;
    var term: @import("tui/tui.zig").Term = if (detach != null) .none else .open;
    var headless = detach != null;
    upgrade.remember(args);
    if (upgrade.resumed) |*rec| {
        // Close-on-exec again: a shell forked from here inherits none.
        rec.closeOnExec(true);
        opts.load_path = rec.dump;
        term = .none;
        for (rec.ttys[0..rec.nttys]) |t| if (t.primary) {
            term = .{ .fd = .{ .fd = t.fd, .termios = t.termios } };
        };
        headless = if (pardes.platform == .gui) !rec.window else rec.nttys == 0;
        daemon.resumeLink(rec.link, rec.stub, kind, opts.ninep_name, headless);
    } else if (daemon.wanted()) {
        if (detach != null or pardes.platform == .gui) {
            _ = daemon.register(null, kind, opts.ninep_name, detach != null);
        } else if (pardes.platform == .tui) fork: {
            // A terminal's session is forked off its stub, which stays the
            // job the shell waits on: Detach (or the terminal's end) ends
            // the job and leaves the session running (daemon.forkSession).
            // The daemon is reached or started first, from this small
            // process, and the terminal opened while it is this one's.
            const conn = daemon.connect(true) orelse break :fork;
            const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0));
            if (fd < 0) {
                daemon.startPending(true);
                _ = std.c.close(conn);
                break :fork;
            }
            // Started in the background, the job stops here until it is
            // brought to the foreground, as one making its terminal raw does.
            // std.posix's termios, not std.c's: glibc's is the bigger struct.
            if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {}
            daemon.forkSession(conn) orelse {
                daemon.startPending(true);
                _ = std.c.close(fd);
                _ = std.c.close(conn);
                break :fork;
            };
            _ = daemon.register(conn, .tty, opts.ninep_name, false);
            term = .{ .fd = .{ .fd = fd } };
        }
    }
    defer daemon.quit();
    errdefer daemon.tellStubExit(1);
    switch (pardes.platform) {
        .tui => @import("tui/tui.zig").run(init, opts, term) catch |err| switch (err) {
            // No controlling terminal (a detached pty, a daemon): said, not
            // an error trace.
            error.NoDevice => {
                std.Io.File.stderr().writeStreamingAll(init.io, "pardes: no terminal to draw on: /dev/tty will not open; run it in a terminal, or --detach\n") catch {};
                std.process.exit(1);
            },
            else => return err,
        },
        .gui => try @import("gui/gui.zig").run(init, opts, headless),
        .macos => unreachable,
    }
    daemon.tellStubExit(0);
}

extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int;
extern "c" fn atexit(f: *const fn () callconv(.c) void) c_int;

/// `pardes --ps`: what the per-user daemon keeps, as a tree; `--kill=<name>`
/// and `--kill-all`: those sessions ended with their shells, a TERM and,
/// for one still there 2 s later, a KILL.
fn manage(io: std.Io, verb: enum { list, kill, killall }, name: []const u8) noreturn {
    if (comptime !daemon.supported) die(io, "this system has no pardes daemon", .{});
    var words_buf: [300]u8 = undefined;
    const words = if (verb == .kill)
        std.fmt.bufPrint(&words_buf, "kill {s}", .{name}) catch die(io, "that name is too long", .{})
    else
        @tagName(verb);
    var buf: [4096]u8 = undefined;
    const said = daemon.ask(words, &buf) orelse die(io, "no pardes daemon is running", .{});
    if (std.mem.startsWith(u8, said, "no ")) die(io, "{s}", .{said[3..]});
    if (verb == .list) {
        var out: [8192]u8 = undefined;
        var w: std.Io.Writer = .fixed(&out);
        var lines = std.mem.tokenizeScalar(u8, said, '\n');
        var orphans = false;
        while (lines.next()) |line| {
            var it = std.mem.tokenizeScalar(u8, line, ' ');
            const what = it.next() orelse continue;
            const pid = it.next() orelse continue;
            var comm_buf: [64]u8 = undefined;
            const comm = commOf(io, pid, &comm_buf);
            switch (std.meta.stringToEnum(enum { daemon, session, client, shell, orphan }, what) orelse continue) {
                .daemon => w.print("pardes daemon {s}\n", .{pid}) catch break,
                .session => {
                    const kind = it.next() orelse "";
                    const state = it.next() orelse "";
                    w.print("  session {s} {s} ({s}, {s})\n", .{ std.mem.trim(u8, it.rest(), " "), pid, kind, state }) catch break;
                },
                .client => w.print("    client {s} {s}\n", .{ pid, comm }) catch break,
                .shell => w.print("    shell {s} {s}\n", .{ pid, comm }) catch break,
                .orphan => {
                    if (!orphans) w.writeAll("  shells no session holds (Adopt takes them, --kill-all ends them)\n") catch break;
                    orphans = true;
                    w.print("    shell {s} {s}\n", .{ pid, comm }) catch break;
                },
            }
        }
        std.Io.File.stdout().writeStreamingAll(io, w.buffered()) catch {};
        std.process.exit(0);
    }
    var pids: [64]std.c.pid_t = undefined;
    var n: usize = 0;
    var it = std.mem.tokenizeScalar(u8, said, ' ');
    _ = it.next(); // ok
    while (it.next()) |p| if (n < pids.len) {
        pids[n] = std.fmt.parseInt(std.c.pid_t, p, 10) catch continue;
        n += 1;
    };
    // Gone once the daemon no longer lists them: a session's link ends with
    // its process, a zombie's too, which kill(pid, 0) would call alive.
    const Gone = struct {
        fn all(list: []const std.c.pid_t, ms: u32) bool {
            var waited: u32 = 0;
            while (true) : (waited += 20) {
                var reply: [4096]u8 = undefined;
                const now = daemon.ask("list", &reply) orelse return true;
                var lines = std.mem.tokenizeScalar(u8, now, '\n');
                const left = while (lines.next()) |line| {
                    var fields = std.mem.tokenizeScalar(u8, line, ' ');
                    if (!std.mem.eql(u8, fields.next() orelse "", "session")) continue;
                    const pid = std.fmt.parseInt(std.c.pid_t, fields.next() orelse "", 10) catch continue;
                    if (std.mem.indexOfScalar(std.c.pid_t, list, pid) != null) break true;
                } else false;
                if (!left) return true;
                if (waited >= ms) return false;
                const ts: std.c.timespec = .{ .sec = 0, .nsec = 20 * std.time.ns_per_ms };
                _ = std.c.nanosleep(&ts, null);
            }
        }
    };
    if (!Gone.all(pids[0..n], 2000)) {
        for (pids[0..n]) |p| _ = std.c.kill(p, .KILL);
        if (!Gone.all(pids[0..n], 1000)) die(io, "a session would not end, even killed", .{});
    }
    std.process.exit(0);
}

/// The command `pid` runs, as /proc says it (Linux); empty where it does not.
fn commOf(io: std.Io, pid: []const u8, buf: *[64]u8) []const u8 {
    var path_buf: [64]u8 = undefined;
    const path = std.fmt.bufPrint(&path_buf, "/proc/{s}/comm", .{pid}) catch return "";
    return std.mem.trimEnd(u8, std.Io.Dir.cwd().readFile(io, path, buf) catch return "", "\n");
}

/// The replica client of this build's frontend: a terminal's (tui.zig) or a
/// window's (gui.zig).
fn clientOf(init: std.process.Init, opts: pardes.Options, path: []const u8, name: []const u8, far: bool) !void {
    switch (pardes.platform) {
        .tui => try @import("tui/tui.zig").remote(init, opts, path, name, far),
        .gui => try @import("gui/gui.zig").remote(init, opts, path, name, far),
        else => unreachable,
    }
}

/// `pardes --attach=<where>:<name>` (`pardes-gui` too): a replica client
/// (tui.zig and gui.zig `remote`), through the socket `where` names, or
/// through `ssh -L` of host `where`'s replica socket to one of this
/// process's.
fn remoteAttach(init: std.process.Init, opts: pardes.Options, where: []const u8, name: []const u8) noreturn {
    const io = init.io;
    if (comptime pardes.platform != .tui and pardes.platform != .gui) unreachable;
    if (std.mem.indexOfScalar(u8, where, '/') != null) {
        clientOf(init, opts, where, name, false) catch |err| die(io, "--attach: {t}", .{err});
        std.process.exit(0);
    }
    // ssh -L <here>:<there> <host>, until the socket here answers.
    var here_buf: [ninep_io.sun_path_len:0]u8 = undefined;
    const tmp = std.mem.span(std.c.getenv("TMPDIR") orelse "/tmp");
    const here = std.fmt.bufPrintSentinel(&here_buf, "{s}/pardes-ssh-{d}.sock", .{ tmp, std.c.getpid() }, 0) catch die(io, "--attach: TMPDIR is too long for a socket's path", .{});
    var there_buf: [ninep_io.sun_path_len + 64:0]u8 = undefined;
    var dir_buf: [ninep_io.sun_path_len:0]u8 = undefined;
    const dir = if (std.c.getenv("PARDES_REMOTE_RUNTIME")) |d| std.mem.span(d) else ninep_io.socketDir(&dir_buf) orelse die(io, "--attach: no runtime directory to name the remote socket by: set PARDES_REMOTE_RUNTIME", .{});
    var forward_buf: [2 * ninep_io.sun_path_len + 64]u8 = undefined;
    const there = std.fmt.bufPrintSentinel(&there_buf, "{s}/pardes-replica.sock", .{dir}, 0) catch unreachable;
    const forward = std.fmt.bufPrintSentinel(&forward_buf, "{s}:{s}", .{ here, there }, 0) catch unreachable;
    var host_buf: [256]u8 = undefined;
    const host = std.fmt.bufPrintSentinel(&host_buf, "{s}", .{where}, 0) catch die(io, "--attach: that host's name is too long", .{});
    var argv: [48:null]?[*:0]const u8 = @splat(null);
    var n: usize = 0;
    var words_buf: [1024]u8 = undefined;
    // Not `ssh -C`: what the session sends a far client is zstd already
    // (replica.zig), and zlib over it costs both ends' time for nothing.
    // ponytail: what the client sends goes as it is, keys and a paste
    // alike; a big paste through a slow link is the ceiling, and would be
    // an envelope of its own. $PARDES_SSH, when set, is the whole command.
    var words = std.mem.tokenizeScalar(u8, std.mem.span(std.c.getenv("PARDES_SSH") orelse "ssh"), ' ');
    var at: usize = 0;
    while (words.next()) |w| {
        if (n >= 40 or at + w.len + 1 > words_buf.len) die(io, "--attach: PARDES_SSH has too many words", .{});
        @memcpy(words_buf[at..][0..w.len], w);
        words_buf[at + w.len] = 0;
        argv[n] = @ptrCast(&words_buf[at]);
        n += 1;
        at += w.len + 1;
    }
    // A terminal asked for and a command that waits, not -N: only an
    // interactive connection gets TCP_NODELAY from ssh and sshd, and with
    // Nagle each key in a burst waited for the last one's ACK, a round trip.
    for ([_][*:0]const u8{ "-tt", "-q", "-o", "ExitOnForwardFailure=yes", "-L", forward.ptr, host.ptr, "exec sleep 2147483647" }) |a| {
        argv[n] = a;
        n += 1;
    }
    _ = std.c.unlink(here);
    const pid = std.c.fork();
    if (pid < 0) die(io, "--attach: no fork for ssh", .{});
    if (pid == 0) {
        // A client killed outright takes its ssh with it.
        daemon.hupOnStubDeath(true);
        const null_fd = std.c.open("/dev/null", .{ .ACCMODE = .RDONLY }, @as(std.c.mode_t, 0));
        if (null_fd >= 0) _ = std.c.dup2(null_fd, 0);
        _ = execvp(argv[0].?, &argv);
        std.c._exit(127);
    }
    // Ended at the client's exit, whatever path it takes there (its own
    // words on a refused redial exit from inside it). ponytail: a client
    // that crashes leaves its socket's file behind; its ssh goes.
    const Ssh = struct {
        var child: std.c.pid_t = 0;
        var path: [:0]const u8 = "";
        fn end() callconv(.c) void {
            if (child > 0) {
                _ = std.c.kill(child, .TERM);
                _ = std.c.waitpid(child, null, 0);
            }
            _ = std.c.unlink(path);
        }
    };
    Ssh.child = pid;
    Ssh.path = here;
    _ = atexit(Ssh.end);
    var waited: u32 = 0;
    while (std.meta.isError(std.Io.Dir.cwd().access(io, here, .{}))) : (waited += 1) {
        var status: c_int = 0;
        if (std.c.waitpid(pid, &status, std.c.W.NOHANG) == pid) {
            Ssh.child = 0;
            die(io, "--attach: ssh to {s} ended before its forward was up", .{where});
        }
        if (waited > 3000) die(io, "--attach: ssh to {s} set up no forward in 30 s", .{where});
        const ts: std.c.timespec = .{ .sec = 0, .nsec = 10 * std.time.ns_per_ms };
        _ = std.c.nanosleep(&ts, null);
    }
    clientOf(init, opts, here, name, true) catch |err| die(io, "--attach: {t}", .{err});
    std.process.exit(0);
}

/// `pardes --attach[=name]` in a terminal: this terminal handed (through
/// the daemon) to the detached session of that name, or the only one, and
/// this process its stub until the session leaves it. `pardes-gui
/// --attach`: the session asked to open its window again, and done. A
/// session attached already, or of the other kind, is joined as a replica
/// client, through this machine's replica socket.
fn attachTo(init: std.process.Init, opts: pardes.Options, name: []const u8) noreturn {
    const io = init.io;
    var words: [600]u8 = undefined;
    if (comptime !daemon.supported) die(io, "--attach: this system has no pardes daemon to attach through", .{});
    if (pardes.platform == .gui) switch (daemon.attach(.gui, name, &.{}, &words)) {
        .ok => std.process.exit(0),
        .no => |why| die(io, "--attach: {s}", .{why}),
        .other => |named| crossAttach(init, opts, named),
    };
    const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0));
    if (fd < 0) die(io, "--attach: no terminal to attach: /dev/tty will not open", .{});
    if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {}
    var pipe: [2]std.c.fd_t = undefined;
    if (std.c.pipe(&pipe) != 0) die(io, "--attach: no pipe for the session to say when it leaves", .{});
    ninep_io.setCloexec(pipe[0]);
    ninep_io.setCloexec(pipe[1]);
    switch (daemon.attach(.tty, name, &.{ fd, pipe[1] }, &words)) {
        .ok => |pid| {
            _ = std.c.close(fd);
            _ = std.c.close(pipe[1]);
            daemon.stubWait(pid, false, pipe[0]);
        },
        .no => |why| die(io, "--attach: {s}", .{why}),
        .other => |named| {
            _ = std.c.close(fd);
            _ = std.c.close(pipe[0]);
            _ = std.c.close(pipe[1]);
            crossAttach(init, opts, named);
        },
    }
}

/// A session attached already or of the other kind (`--attach`'s): a
/// replica client of it here.
fn crossAttach(init: std.process.Init, opts: pardes.Options, name: []const u8) noreturn {
    var sock_buf: [ninep_io.sun_path_len:0]u8 = undefined;
    const sock = daemon.replicaSocket(&sock_buf) orelse die(init.io, "--attach: no runtime directory for the replica socket", .{});
    remoteAttach(init, opts, sock, name);
}

fn parseCtrlKey(raw: []const u8) ?u21 {
    var value = std.mem.trim(u8, raw, " \t\r\n");
    if (value.len >= 5 and std.ascii.eqlIgnoreCase(value[0..5], "ctrl-")) {
        value = value[5..];
    } else if (value.len >= 5 and std.ascii.eqlIgnoreCase(value[0..5], "ctrl+")) {
        value = value[5..];
    } else if (value.len == 2 and value[0] == '^') {
        value = value[1..];
    }
    if (value.len != 1) return null;
    const c = std.ascii.toLower(value[0]);
    if (c < 'a' or c > 'z' or c == 'c') return null;
    return c;
}

test {
    _ = pardes.config.User;
    _ = @import("crash.zig");
    _ = @import("memory.zig");
    _ = @import("locations.zig");
    _ = @import("fs.zig");
    _ = @import("wire.zig");
    _ = @import("vaxis_input.zig");
    _ = @import("daemon.zig");
    _ = @import("9p_io.zig");
    _ = @import("9p_io.zig").Client;
    _ = @import("host_io.zig");
    _ = @import("host_io.zig").Shell;
    _ = @import("host_io.zig").Lsp;
    // Its tests too: imported by the hosts only, it was never collected.
    _ = @import("file_watch.zig");
    _ = @import("lsp/lsp_client.zig");
    _ = @import("lsp/lsp.zig");
    if (comptime pardes.platform == .tui) {
        _ = @import("tui/tui.zig");
    }
    if (comptime pardes.platform == .gui) _ = @import("gui/gui.zig");
    if (comptime pardes.font_picker) _ = @import("fonts.zig");
}

/// Where Recent's file (0.24) and the store before it were kept:
/// $XDG_STATE_HOME/pardes, else ~/.local/state/pardes. A state file that
/// holds no Recent yet reads them once (Db.zig).
fn oldRecentDir(arena: std.mem.Allocator, env: *const std.process.Environ.Map) ?[]const u8 {
    if (env.get("XDG_STATE_HOME")) |base| if (base.len != 0 and std.Io.Dir.path.isAbsolute(base))
        return std.Io.Dir.path.join(arena, &.{ base, "pardes" }) catch null;
    const home = env.get("HOME") orelse return null;
    if (home.len == 0) return null;
    return std.Io.Dir.path.join(arena, &.{ home, ".local", "state", "pardes" }) catch null;
}