6c5f6a37

feat: one binary — `mux d` / `mux a` / `mux web`, and the client with no letter

a73x 2026-08-28 22:34

Commit message

feat: one binary — `mux d` / `mux a` / `mux web`, and the client with no letter

The four mains stay four files and become four modules of one root,
src/cli/mux.zig, which owns the mode word and nothing else. Each is handed
the argv slice it already read — args[1..], whose [0] is the mode word where
the program name used to be — so no parser changed a line.

`mux run …` is the one alias, and it is a bridge rather than a convenience:
a daemon of v0.0.1-15 or older execs its upgrade candidate as
`<binary> run --resume-fd N`.

Messages are prefixed with the words the user typed: `mux d:`, `mux a:`,
`mux web:`, plain `mux:`. `--version` answers `mux <version>` in every mode,
which is what the program is now called.

build.zig

Old		New
@@ -261,7 +261,7 @@ const mod_table = [_]ModSpec{
261	// renders: `quic_client` for the remote arm and `xdg` for the one	261	// renders: `quic_client` for the remote arm and `xdg` for the one
262	// key-resolution rule all three binaries obey. Deliberately still no	262	// key-resolution rule all three binaries obey. Deliberately still no
263	// engine and no replica — muxa has nothing to draw.	263	// engine and no replica — muxa has nothing to draw.
264	.{ .name = "muxa", .path = "src/cli/muxa.zig", .layer = 2, .link_libc = true, .imports = &.{ "protocol", "sockpath", "quic_client", "quic", "xdg", "cliflags" }, .quic_tests = true },	264	.{ .name = "agent_main", .path = "src/cli/muxa.zig", .layer = 2, .link_libc = true, .imports = &.{ "protocol", "sockpath", "quic_client", "quic", "xdg", "cliflags" }, .quic_tests = true },
265	.{ .name = "wsclient", .path = "test/wsclient.zig", .layer = 2, .link_libc = true, .imports = &.{ "engine", "replica", "protocol", "script" } },	265	.{ .name = "wsclient", .path = "test/wsclient.zig", .layer = 2, .link_libc = true, .imports = &.{ "engine", "replica", "protocol", "script" } },
266	// ---- layer 3 ----	266	// ---- layer 3 ----
267	// Dialling, and what a chord means. The client is the only thing that	267	// Dialling, and what a chord means. The client is the only thing that
@@ -280,7 +280,7 @@ const mod_table = [_]ModSpec{
280	// the sun_path bound, checked before any verb acts on the path; and the	280	// the sun_path bound, checked before any verb acts on the path; and the
281	// keygen round-trip test needs a directory to generate into, which the	281	// keygen round-trip test needs a directory to generate into, which the
282	// daemon itself never touches.	282	// daemon itself never touches.
283	.{ .name = "exe", .path = "src/cli/main.zig", .layer = 3, .link_libc = true, .imports = &.{ "server", "protocol", "proxy", "quic", "quic_server", "xdg", "spawn", "handoff", "sockpath", "upgrade", "cliflags" }, .test_imports = &.{"testtmp"}, .quic_tests = true },	283	.{ .name = "daemon_main", .path = "src/cli/main.zig", .layer = 3, .link_libc = true, .imports = &.{ "server", "protocol", "proxy", "quic", "quic_server", "xdg", "spawn", "handoff", "sockpath", "upgrade", "cliflags" }, .test_imports = &.{"testtmp"}, .quic_tests = true },
284	// ---- layer 4 ----	284	// ---- layer 4 ----
285	// The muxweb hub's HTTP/WebSocket decisions: Origin gate, route	285	// The muxweb hub's HTTP/WebSocket decisions: Origin gate, route
286	// table, WS endpoint naming. Assets are injected (the exe root	286	// table, WS endpoint naming. Assets are injected (the exe root
@@ -304,14 +304,18 @@ const mod_table = [_]ModSpec{
304	// one grammar, not three. Resolution itself now lives in the Hub, so	304	// one grammar, not three. Resolution itself now lives in the Hub, so
305	// handoff/protocol left with it; sockpath stays for the one startup	305	// handoff/protocol left with it; sockpath stays for the one startup
306	// message that names the sun_path bound.	306	// message that names the sun_path bound.
307	.{ .name = "webhub_main", .path = "src/cli/webhub_main.zig", .layer = 5, .link_libc = true, .imports = &.{ "client", "webhub", "wall", "xdg", "sockpath", "cliflags" }, .quic_tests = true },	307	.{ .name = "hub_main", .path = "src/cli/webhub_main.zig", .layer = 5, .link_libc = true, .imports = &.{ "client", "webhub", "wall", "xdg", "sockpath", "cliflags" }, .quic_tests = true },
308	// sockpath is the sun_path bound only; the client binds no socket itself.	308	// sockpath is the sun_path bound only; the client binds no socket itself.
309	// protocol is the session-name validator alone (validSessionName): a bad	309	// protocol is the session-name validator alone (validSessionName): a bad
310	// --session has to be a usage error here, at parse, not bytes some	310	// --session has to be a usage error here, at parse, not bytes some
311	// daemon downstream has to notice and refuse. Layer 5 since `mux wall`	311	// daemon downstream has to notice and refuse. Layer 5 since `mux wall`
312	// pulled in wallview (layer 4); wall rides along for the no-arg wall	312	// pulled in wallview (layer 4); wall rides along for the no-arg wall
313	// (the state file the browser hub builds).	313	// (the state file the browser hub builds).
314	.{ .name = "mux", .path = "src/cli/mux_main.zig", .layer = 5, .link_libc = true, .imports = &.{ "client", "protocol", "xdg", "spawn", "handoff", "sockpath", "wallview", "wall", "hosts", "cliflags" }, .test_imports = &.{"testtmp"}, .quic_tests = true },	314	.{ .name = "client_main", .path = "src/cli/mux_main.zig", .layer = 5, .link_libc = true, .imports = &.{ "client", "protocol", "xdg", "spawn", "handoff", "sockpath", "wallview", "wall", "hosts", "cliflags" }, .test_imports = &.{"testtmp"}, .quic_tests = true },
		315	// ---- layer 6: the one binary ----
		316	// Four words, one image. Nothing but the mode letter lives here, which
		317	// is why it may sit above every other main without owning any of them.
		318	.{ .name = "mux", .path = "src/cli/mux.zig", .layer = 6, .link_libc = true, .imports = &.{ "daemon_main", "agent_main", "hub_main", "client_main" } },
315	};	319	};
316		320
317	/// Comptime row lookup. Every hand-written module name in this file goes	321	/// Comptime row lookup. Every hand-written module name in this file goes
@@ -759,15 +763,16 @@ fn docGate(b: std.Build, target: std.Build.ResolvedTarget, check_step: std.Bui
759	/// client forever — and a wedged step prints nothing at all. Failing	763	/// client forever — and a wedged step prints nothing at all. Failing
760	/// first is what makes the catch legible. script leads for the same	764	/// first is what makes the catch legible. script leads for the same
761	/// reason: instant, allocation-only, and both fixtures inherit its	765	/// reason: instant, allocation-only, and both fixtures inherit its
762	/// escape pins. mux and exe are executable roots but carry the argument	766	/// escape pins. The mains are roots of nothing but the one binary, and
763	/// parsers — a test that is never built is not a test (decisions.md).	767	/// they carry the argument parsers — a test that is never built is not a
		768	/// test (decisions.md).
764	const test_order = [_][]const u8{	769	const test_order = [_][]const u8{
765	"script", "select", "protocol", "client_core", "interact", "engine", "pty",	770	"script", "select", "protocol", "client_core", "interact", "engine", "pty",
766	"delta", "cmd", "wall", "hosts", "upgrade", "shellint", "replica",	771	"delta", "cmd", "wall", "hosts", "upgrade", "shellint", "replica",
767	"keymap", "webhub", "wallview", "sockpath", "muxa", "server", "client",	772	"keymap", "webhub", "wallview", "sockpath", "agent_main", "server", "client",
768	"proxy", "mux", "quic", "quic_server", "exe", "testtmp", "quic_client",	773	"proxy", "client_main", "quic", "quic_server", "daemon_main", "testtmp", "quic_client",
769	"predict", "rawmode", "delaypipe", "xdg", "spawn", "handoff", "paint",	774	"predict", "rawmode", "delaypipe", "xdg", "spawn", "handoff", "paint",
770	"layout", "render", "ptyclient", "webhub_main", "wsclient", "cliflags",	775	"layout", "render", "ptyclient", "hub_main", "wsclient", "cliflags", "mux",
771	};	776	};
772		777
773	comptime {	778	comptime {
@@ -865,52 +870,46 @@ pub fn build(b: *std.Build) void {
865	// jurisdiction, explicit.	870	// jurisdiction, explicit.
866	const engine_mod = mods[comptime idxOf("engine")];	871	const engine_mod = mods[comptime idxOf("engine")];
867	const mux_mod = mods[comptime idxOf("mux")];	872	const mux_mod = mods[comptime idxOf("mux")];
868	const exe_mod = mods[comptime idxOf("exe")];	873	const client_main_mod = mods[comptime idxOf("client_main")];
869	const muxa_mod = mods[comptime idxOf("muxa")];	874	const daemon_main_mod = mods[comptime idxOf("daemon_main")];
		875	const agent_main_mod = mods[comptime idxOf("agent_main")];
870	const rawmode_mod = mods[comptime idxOf("rawmode")];	876	const rawmode_mod = mods[comptime idxOf("rawmode")];
871	const delaypipe_mod = mods[comptime idxOf("delaypipe")];	877	const delaypipe_mod = mods[comptime idxOf("delaypipe")];
872	const render_mod = mods[comptime idxOf("render")];	878	const render_mod = mods[comptime idxOf("render")];
873	const ptyclient_mod = mods[comptime idxOf("ptyclient")];	879	const ptyclient_mod = mods[comptime idxOf("ptyclient")];
874	const wsclient_mod = mods[comptime idxOf("wsclient")];	880	const wsclient_mod = mods[comptime idxOf("wsclient")];
875	const webhub_main_mod = mods[comptime idxOf("webhub_main")];	881	const hub_main_mod = mods[comptime idxOf("hub_main")];
876		882
877	if (ghostty_dep) \|dep\| {	883	if (ghostty_dep) \|dep\| {
878	engine_mod.addImport("ghostty-vt", dep.module("ghostty-vt"));	884	engine_mod.addImport("ghostty-vt", dep.module("ghostty-vt"));
879	}	885	}
880	mux_mod.addImport("build_options", version_opts.createModule());	886	// ONE module object, shared: the four mains link into one binary now, and
881	exe_mod.addImport("build_options", version_opts.createModule());	887	// a second instance of the same root file in one compilation is "file
882	webhub_main_mod.addImport("build_options", version_opts.createModule());	888	// exists in modules 'build_options' and 'build_options0'".
883	muxa_mod.addImport("build_options", version_opts.createModule());	889	const build_opts_mod = version_opts.createModule();
		890	client_main_mod.addImport("build_options", build_opts_mod);
		891	daemon_main_mod.addImport("build_options", build_opts_mod);
		892	hub_main_mod.addImport("build_options", build_opts_mod);
		893	agent_main_mod.addImport("build_options", build_opts_mod);
884	// A row with test_imports gets a SEPARATE module for its test twin, and	894	// A row with test_imports gets a SEPARATE module for its test twin, and
885	// build_options is outside the table's jurisdiction — so every such twin	895	// build_options is outside the table's jurisdiction — so every such twin
886	// needs it by hand, or the argument parsers lose the version they print.	896	// needs it by hand, or the argument parsers lose the version they print.
887	test_mods[comptime idxOf("exe")].addImport("build_options", version_opts.createModule());	897	test_mods[comptime idxOf("daemon_main")].addImport("build_options", build_opts_mod);
888	test_mods[comptime idxOf("mux")].addImport("build_options", version_opts.createModule());	898	test_mods[comptime idxOf("client_main")].addImport("build_options", build_opts_mod);
889		899
890	const exe = b.addExecutable(.{ .name = "muxd", .root_module = exe_mod });	900	// ONE product binary. The four mains are modules under it, reached by
		901	// the mode word rather than by four names on PATH — which is also what
		902	// lets the client's auto-start fork into the daemon instead of hunting
		903	// for a sibling. The fixtures below stay separate: they stand in for
		904	// users, not for the product.
		905	const mux_exe = b.addExecutable(.{ .name = "mux", .root_module = mux_mod });
891	// Zig 0.15's self-hosted x86_64 linker can't handle the .sframe	906	// Zig 0.15's self-hosted x86_64 linker can't handle the .sframe
892	// sections emitted by gcc >= 16 crt1.o on this system; LLD can.	907	// sections emitted by gcc >= 16 crt1.o on this system; LLD can.
893	exe.use_llvm = true;
894	exe.use_lld = true;
895	// The daemon is the side that will listen (Task 2c). Nothing references
896	// these symbols yet, so nothing is pulled in.
897	linkQuic(b, exe, quic);
898	b.installArtifact(exe);
899
900	const mux_exe = b.addExecutable(.{ .name = "mux", .root_module = mux_mod });
901	mux_exe.use_llvm = true;	908	mux_exe.use_llvm = true;
902	mux_exe.use_lld = true;	909	mux_exe.use_lld = true;
903	// The client speaks QUIC now, so it carries the stack too.
904	linkQuic(b, mux_exe, quic);	910	linkQuic(b, mux_exe, quic);
905	b.installArtifact(mux_exe);	911	b.installArtifact(mux_exe);
906		912
907	const muxa_exe = b.addExecutable(.{ .name = "muxa", .root_module = muxa_mod });
908	muxa_exe.use_llvm = true;
909	muxa_exe.use_lld = true;
910	// The agent client dials remote daemons now, so it carries the stack too.
911	linkQuic(b, muxa_exe, quic);
912	b.installArtifact(muxa_exe);
913
914	const rawmode_exe = b.addExecutable(.{ .name = "rawmode", .root_module = rawmode_mod });	913	const rawmode_exe = b.addExecutable(.{ .name = "rawmode", .root_module = rawmode_mod });
915	rawmode_exe.use_llvm = true;	914	rawmode_exe.use_llvm = true;
916	rawmode_exe.use_lld = true;	915	rawmode_exe.use_lld = true;
@@ -1001,14 +1000,9 @@ pub fn build(b: *std.Build) void {
1001	// The page's three assets arrive as anonymous imports so @embedFile	1000	// The page's three assets arrive as anonymous imports so @embedFile
1002	// can name them; the wasm one is the artifact itself, which also	1001	// can name them; the wasm one is the artifact itself, which also
1003	// sequences the wasm build before the hub's.	1002	// sequences the wasm build before the hub's.
1004	webhub_main_mod.addAnonymousImport("index.html", .{ .root_source_file = b.path("web/index.html") });	1003	hub_main_mod.addAnonymousImport("index.html", .{ .root_source_file = b.path("web/index.html") });
1005	webhub_main_mod.addAnonymousImport("mux.js", .{ .root_source_file = b.path("web/mux.js") });	1004	hub_main_mod.addAnonymousImport("mux.js", .{ .root_source_file = b.path("web/mux.js") });
1006	webhub_main_mod.addAnonymousImport("mux_core.wasm", .{ .root_source_file = wasm_exe.getEmittedBin() });	1005	hub_main_mod.addAnonymousImport("mux_core.wasm", .{ .root_source_file = wasm_exe.getEmittedBin() });
1007	const webhub_exe = b.addExecutable(.{ .name = "muxweb", .root_module = webhub_main_mod });
1008	webhub_exe.use_llvm = true;
1009	webhub_exe.use_lld = true;
1010	linkQuic(b, webhub_exe, quic);
1011	b.installArtifact(webhub_exe);
1012		1006
1013	const test_step = b.step("test", "Run unit tests");	1007	const test_step = b.step("test", "Run unit tests");
1014	test_step.dependOn(&client_core_wasm_guard.step);	1008	test_step.dependOn(&client_core_wasm_guard.step);
@@ -1057,7 +1051,6 @@ pub fn build(b: *std.Build) void {
1057	}	1051	}
1058		1052
1059	const e2e = b.addSystemCommand(&.{"test/e2e.sh"});	1053	const e2e = b.addSystemCommand(&.{"test/e2e.sh"});
1060	e2e.addArtifactArg(exe);
1061	e2e.addArtifactArg(mux_exe);	1054	e2e.addArtifactArg(mux_exe);
1062	// The prediction scenarios need a deterministic editor and a slow path;	1055	// The prediction scenarios need a deterministic editor and a slow path;
1063	// passed as artifacts so the suite runs against the binaries this build	1056	// passed as artifacts so the suite runs against the binaries this build
@@ -1067,14 +1060,6 @@ pub fn build(b: *std.Build) void {
1067	e2e.addArtifactArg(render_exe);	1060	e2e.addArtifactArg(render_exe);
1068	e2e.addArtifactArg(ptyclient_exe);	1061	e2e.addArtifactArg(ptyclient_exe);
1069	e2e.addArtifactArg(wsclient_exe);	1062	e2e.addArtifactArg(wsclient_exe);
1070	e2e.addArtifactArg(webhub_exe);
1071	// muxa, for the M18 block alone: it is the one verb family that can ask
1072	// about a session WITHOUT attaching to it, and the sessions it asks
1073	// about have to be created by `mux` first — which is why the question
1074	// is asked here rather than in the agent suite, where there is no `mux`
1075	// to create a named session with. test/agent.sh remains muxa's own home
1076	// for everything that does not need two sessions to exist.
1077	e2e.addArtifactArg(muxa_exe);
1078	const e2e_step = b.step("e2e", "Run end-to-end test");	1063	const e2e_step = b.step("e2e", "Run end-to-end test");
1079	e2e_step.dependOn(&e2e.step);	1064	e2e_step.dependOn(&e2e.step);
1080		1065
@@ -1086,29 +1071,25 @@ pub fn build(b: *std.Build) void {
1086	// runs when somebody types the script is the shape a regression ships	1071	// runs when somebody types the script is the shape a regression ships
1087	// through.	1072	// through.
1088	const agent = b.addSystemCommand(&.{"test/agent.sh"});	1073	const agent = b.addSystemCommand(&.{"test/agent.sh"});
1089	agent.addArtifactArg(exe);	1074	agent.addArtifactArg(mux_exe);
1090	agent.addArtifactArg(muxa_exe);
1091	const agent_step = b.step("agent", "Run the agent-surface end-to-end suite");	1075	const agent_step = b.step("agent", "Run the agent-surface end-to-end suite");
1092	agent_step.dependOn(&agent.step);	1076	agent_step.dependOn(&agent.step);
1093		1077
1094	const soak = b.addSystemCommand(&.{"test/soak.sh"});	1078	const soak = b.addSystemCommand(&.{"test/soak.sh"});
1095	soak.addArtifactArg(exe);	1079	// The same list the e2e step passes, in the same order: soak IS that
		1080	// suite run N times, so an argument added to one and not the other
		1081	// makes every soak run abort on an unbound variable before its first
		1082	// scenario.
1096	soak.addArtifactArg(mux_exe);	1083	soak.addArtifactArg(mux_exe);
1097	soak.addArtifactArg(rawmode_exe);	1084	soak.addArtifactArg(rawmode_exe);
1098	soak.addArtifactArg(delaypipe_exe);	1085	soak.addArtifactArg(delaypipe_exe);
1099	soak.addArtifactArg(render_exe);	1086	soak.addArtifactArg(render_exe);
1100	soak.addArtifactArg(ptyclient_exe);	1087	soak.addArtifactArg(ptyclient_exe);
1101	soak.addArtifactArg(wsclient_exe);	1088	soak.addArtifactArg(wsclient_exe);
1102	soak.addArtifactArg(webhub_exe);
1103	// Same list as the e2e step, muxa included: soak IS the e2e suite run N
1104	// times, so an argument added to one and not the other makes every soak
1105	// run abort on an unbound variable before its first scenario.
1106	soak.addArtifactArg(muxa_exe);
1107	const soak_step = b.step("soak", "Run the e2e suite SOAK_N times (default 10)");	1089	const soak_step = b.step("soak", "Run the e2e suite SOAK_N times (default 10)");
1108	soak_step.dependOn(&soak.step);	1090	soak_step.dependOn(&soak.step);
1109		1091
1110	const bench = b.addSystemCommand(&.{"test/bench.sh"});	1092	const bench = b.addSystemCommand(&.{"test/bench.sh"});
1111	bench.addArtifactArg(exe);
1112	bench.addArtifactArg(mux_exe);	1093	bench.addArtifactArg(mux_exe);
1113	const bench_step = b.step("bench", "Measure delta vs snapshot bytes");	1094	const bench_step = b.step("bench", "Measure delta vs snapshot bytes");
1114	bench_step.dependOn(&bench.step);	1095	bench_step.dependOn(&bench.step);

docscheck.budget

Old		New
@@ -58,3 +58,4 @@ wall_test_picker.zig 0
58	wall_test_pump.zig 0	58	wall_test_pump.zig 0
59	wall_test_layout.zig 0	59	wall_test_layout.zig 0
60	wall_test_wall.zig 0	60	wall_test_wall.zig 0
		61	mux.zig 0

src/cli/flags.zig

src/cli/main.zig

src/cli/mux.zig

@@ @@ -0,0 +1,43 @@ @@
+//! mux — the one binary. The first word picks a mode: `d` is the daemon,
+//! `a` the JSON agent surface, `web` the browser hub, and anything else
+//! (including nothing) is the client. Each mode's own parser then reads the
+//! rest, so this file owns the mode letter and nothing else: there is no
+//! second flag grammar here, and no argv[0] dispatch — the four programs
+//! became four words, not four names for one file.
+const std = @import("std");
+const daemon = @import("daemon_main");
+const agent = @import("agent_main");
+const hub = @import("hub_main");
+const client = @import("client_main");
+pub fn main() !u8 {
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
+    defer if (gpa.deinit() == .leak)
+        std.debug.print("mux: LEAK: allocations outlived deinit\n", .{});
+    const alloc = gpa.allocator();
+    const args = try std.process.argsAlloc(alloc);
+    defer std.process.argsFree(alloc, args);
+    if (args.len > 1) {
+        // Each mode is handed a slice whose [0] is the word the user typed
+        // and whose [1..] is its own line — the shape every one of these
+        // parsers already reads, from back when [0] was the program name.
+        const rest = args[1..];
+        if (std.mem.eql(u8, args[1], "d")) return daemon.main(rest);
+        if (std.mem.eql(u8, args[1], "a")) return agent.main(rest);
+        if (std.mem.eql(u8, args[1], "web")) return hub.main(rest);
+        // The bridge for daemons of v0.0.1-15 and older, and the only word
+        // that means a mode without naming one. Their upgrade execs the
+        // candidate as `<binary> run --resume-fd N` (the argv built in
+        // server.zig's upgradeExec), so a v15 daemon can only exec its way
+        // into this binary if bare `run` still reaches the daemon. Nothing
+        // else is aliased: `mux stop` is a host called "stop".
+        if (std.mem.eql(u8, args[1], "run")) return daemon.main(args);
+    }
+    return client.main(args);
+}
+test {
+    std.testing.refAllDeclsRecursive(@This());
+}

src/cli/mux_main.zig

Old		New
@@ -1,6 +1,7 @@
1	//! mux — client binary. `mux [--sock PATH]` attaches to the local muxd;	1	//! `mux` with no mode letter — the client. `mux [--sock PATH]` attaches
		2	//! to the local daemon;
2	//! `mux --via CMD` attaches over CMD's stdio instead (any command that	3	//! `mux --via CMD` attaches over CMD's stdio instead (any command that
3	//! exposes a session socket as a byte pipe, e.g. `ssh host muxd proxy`);	4	//! exposes a session socket as a byte pipe, e.g. `ssh host mux d proxy`);
4	//! `mux HOST` runs the ssh→QUIC handoff — ssh fetches the daemon's QUIC	5	//! `mux HOST` runs the ssh→QUIC handoff — ssh fetches the daemon's QUIC
5	//! coordinates and carries the session only if the QUIC dial does not.	6	//! coordinates and carries the session only if the QUIC dial does not.
6	//!	7	//!
@@ -25,13 +26,24 @@ const wall = @import("wall");
25	const cliflags = @import("cliflags");	26	const cliflags = @import("cliflags");
26	const TmpDir = @import("testtmp").TmpDir;	27	const TmpDir = @import("testtmp").TmpDir;
27		28
		29	/// The whole tree's root page. The four modes come first because the mode
		30	/// word is the first thing typed; the rest of the page is the client's,
		31	/// because the client is what `mux` with no mode word runs. Each other mode
		32	/// documents itself under its own `--help`.
28	const usage =	33	const usage =
29	\\usage: mux [HOST \| --sock PATH \| --via CMD \| quic://HOST[:PORT]]	34	\\usage: mux [TARGET ...] attach, or the wall (this page)
		35	\\ mux d VERB ... the daemon: run start stop stats dump proxy
		36	\\ endpoint keygen upgrade (`mux d --help`)
		37	\\ mux a VERB ... the agent surface, one JSON object per verb
		38	\\ (`mux a --help`)
		39	\\ mux web [TARGET ...] the browser hub (`mux web --help`)
		40	\\
		41	\\ mux [HOST \| --sock PATH \| --via CMD \| quic://HOST[:PORT]]
30	\\ HOST attaches over ssh and hands off to QUIC when the daemon offers it	42	\\ HOST attaches over ssh and hands off to QUIC when the daemon offers it
31	\\ (muxd must be on HOST's PATH; cached coordinates make later attaches	43	\\ (`mux` must be on HOST's PATH; cached coordinates make later attaches
32	\\ skip ssh entirely)	44	\\ skip ssh entirely)
33	\\ quic://HOST[:PORT] (PORT defaults to 4433) uses --key FILE,	45	\\ quic://HOST[:PORT] (PORT defaults to 4433) uses --key FILE,
34	\\ MUX_KEY_FILE, or ~/.config/mux/key; muxd must be running with a	46	\\ MUX_KEY_FILE, or ~/.config/mux/key; the daemon must be running with a
35	\\ matching --quic and key	47	\\ matching --quic and key
36	\\ [--quic-idle-ms N] tunes how fast a dead link is noticed	48	\\ [--quic-idle-ms N] tunes how fast a dead link is noticed
37	\\ [--session NAME] attaches to (or creates) a named session instead of	49	\\ [--session NAME] attaches to (or creates) a named session instead of
@@ -48,7 +60,7 @@ const usage =
48	\\ mux hosts rm SPELLING take one off (its sessions keep running)	60	\\ mux hosts rm SPELLING take one off (its sessions keep running)
49	\\	61	\\
50	\\ SPELLING names a DAEMON — HOST, quic://HOST[:PORT], or --sock PATH	62	\\ SPELLING names a DAEMON — HOST, quic://HOST[:PORT], or --sock PATH
51	\\ (one argument, or two as in muxweb) — and never a session: `#NAME`	63	\\ (one argument, or two as in `mux web`) — and never a session: `#NAME`
52	\\ is refused, because the wall shows every session a daemon has.	64	\\ is refused, because the wall shows every session a daemon has.
53	\\	65	\\
54	\\ On the wall, `Ctrl-\ 1-9` focuses a tile and types into it,	66	\\ On the wall, `Ctrl-\ 1-9` focuses a tile and types into it,
@@ -76,7 +88,7 @@ const ParseResult = union(enum) {
76	attach: struct { sock: ?[]const u8 = null, via: ?[]const u8 = null, session: []const u8 = "", agent: bool = false },	88	attach: struct { sock: ?[]const u8 = null, via: ?[]const u8 = null, session: []const u8 = "", agent: bool = false },
77	/// A bare hostname: the ssh recipe is built from it in main, where there	89	/// A bare hostname: the ssh recipe is built from it in main, where there
78	/// is an allocator to build it with. `idle_ms` rides along because the	90	/// is an allocator to build it with. `idle_ms` rides along because the
79	/// handoff ends in a QUIC link like any other — muxweb's HOST tiles	91	/// handoff ends in a QUIC link like any other — the hub's HOST tiles
80	/// have always carried it, and mux dropping it on the floor made	92	/// have always carried it, and mux dropping it on the floor made
81	/// `--quic-idle-ms` silently do nothing on exactly the spelling most	93	/// `--quic-idle-ms` silently do nothing on exactly the spelling most
82	/// people use.	94	/// people use.
@@ -251,7 +263,7 @@ fn parseArgs(args: []const [:0]const u8, env_key: ?[]const u8) ParseError!ParseR
251	} };	263	} };
252	}	264	}
253	// A key with no quic:// has nothing to authenticate and is ignored	265	// A key with no quic:// has nothing to authenticate and is ignored
254	// rather than refused: unlike muxd, where --key without --quic means a	266	// rather than refused: unlike the daemon, where --key without --quic means a
255	// listener was meant, here it is one env var away from being set for	267	// listener was meant, here it is one env var away from being set for
256	// every invocation in a shell, and refusing `mux --sock ...` because	268	// every invocation in a shell, and refusing `mux --sock ...` because
257	// MUX_KEY_FILE happens to be exported would be absurd.	269	// MUX_KEY_FILE happens to be exported would be absurd.
@@ -259,15 +271,14 @@ fn parseArgs(args: []const [:0]const u8, env_key: ?[]const u8) ParseError!ParseR
259	return .{ .attach = .{ .sock = o.sock, .via = o.via, .session = session, .agent = o.agent } };	271	return .{ .attach = .{ .sock = o.sock, .via = o.via, .session = session, .agent = o.agent } };
260	}	272	}
261		273
262	pub fn main() !u8 {	274	/// The bare `mux`: no mode letter, so the words are a transport or
		275	/// nothing. argv is the dispatcher's, program name and all.
		276	pub fn main(args: []const [:0]const u8) !u8 {
263	var gpa: std.heap.DebugAllocator(.{}) = .init;	277	var gpa: std.heap.DebugAllocator(.{}) = .init;
264	defer if (gpa.deinit() == .leak)	278	defer if (gpa.deinit() == .leak)
265	std.debug.print("mux: LEAK: allocations outlived deinit\n", .{});	279	std.debug.print("mux: LEAK: allocations outlived deinit\n", .{});
266	const alloc = gpa.allocator();	280	const alloc = gpa.allocator();
267		281
268	const args = try std.process.argsAlloc(alloc);
269	defer std.process.argsFree(alloc, args);
270
271	// A subcommand, checked before the flag parse: `hosts` edits or reads a	282	// A subcommand, checked before the flag parse: `hosts` edits or reads a
272	// file and dials no session, so it is not a transport spelling.	283	// file and dials no session, so it is not a transport spelling.
273	if (args.len > 1 and std.mem.eql(u8, args[1], "hosts"))	284	if (args.len > 1 and std.mem.eql(u8, args[1], "hosts"))
@@ -336,7 +347,7 @@ pub fn main() !u8 {
336	.given, .default => \|p\| p,	347	.given, .default => \|p\| p,
337	.missing => \|p\| {	348	.missing => \|p\| {
338	std.debug.print(	349	std.debug.print(
339	"mux: no key: pass --key, set MUX_KEY_FILE, or run `muxd keygen` (default {s})\n",	350	"mux: no key: pass --key, set MUX_KEY_FILE, or run `mux d keygen` (default {s})\n",
340	.{p},	351	.{p},
341	);	352	);
342	return 2;	353	return 2;
@@ -352,7 +363,7 @@ pub fn main() !u8 {
352	// The handoff recipe: ssh fetches the coordinates (and, on a	363	// The handoff recipe: ssh fetches the coordinates (and, on a
353	// cold attach, carries the session if QUIC cannot), while a	364	// cold attach, carries the session if QUIC cannot), while a
354	// warm attach dials from the cache and never spawns ssh at all.	365	// warm attach dials from the cache and never spawns ssh at all.
355	// handoff.recipeFor owns both pieces; muxweb builds its HOST	366	// handoff.recipeFor owns both pieces; the hub builds its HOST
356	// tiles from the same call.	367	// tiles from the same call.
357	const r = try handoff.recipeFor(alloc, h.name, false);	368	const r = try handoff.recipeFor(alloc, h.name, false);
358	defer r.deinit(alloc);	369	defer r.deinit(alloc);
@@ -404,25 +415,10 @@ fn defaultSock(alloc: std.mem.Allocator) !?[]const u8 {
404	};	415	};
405	}	416	}
406		417
407	/// Auto-start: give a local attach a daemon to land on, and the ONLY	418	/// The ONLY auto-start left, and it starts this image by its own /proc
408	/// auto-start left. False when it cannot — the line saying why is already	419	/// link — no name to look up, so none to get wrong.
409	/// printed. Unix-socket transport only: quic:// has nothing local to spawn,
410	/// and `--via` starts nothing at all, because the remote proxy reads a box
411	/// (README's `ssh HOST 'muxd start'` is the answer there).
412	fn ensureLocalDaemon(alloc: std.mem.Allocator, sock_path: []const u8) !bool {	420	fn ensureLocalDaemon(alloc: std.mem.Allocator, sock_path: []const u8) !bool {
413	const muxd_path = try spawn.findInPath(	421	return spawn.ensureForAttach(alloc, sock_path, "mux");
414	alloc,
415	std.posix.getenv("PATH") orelse "",
416	"muxd",
417	);
418	defer if (muxd_path) \|p\| alloc.free(p);
419	if (muxd_path) \|exe\| return spawn.ensureForAttach(alloc, exe, sock_path, "mux");
420	// No muxd anywhere AND nothing serving: only now is the missing binary
421	// the user's problem, and both facts fit in one honest line. A live
422	// daemon needs no binary on PATH.
423	if (spawn.probe(sock_path)) return true;
424	std.debug.print("mux: no daemon on {s} and no muxd in PATH to start one\n", .{sock_path});
425	return false;
426	}	422	}
427		423
428	/// Whether the wall has to start the local daemon itself. Asked of the OS,	424	/// Whether the wall has to start the local daemon itself. Asked of the OS,
@@ -459,10 +455,10 @@ fn attachLocal(
459	return 2;	455	return 2;
460	}	456	}
461		457
462	// The same `sun_path` guard muxd applies (main.zig), for the same	458	// The same `sun_path` guard the daemon applies (main.zig), for the same
463	// reason and off the same constant. It sits before the PATH search	459	// reason and off the same constant. It sits before the PATH search
464	// rather than at the connect because auto-start would otherwise reach	460	// rather than at the connect because auto-start would otherwise reach
465	// it first: mux finds muxd, spawns a child that refuses the path	461	// it first: mux forks a daemon that refuses the path
466	// instantly, and polls the full 2s into "daemon did not answer" — a	462	// instantly, and polls the full 2s into "daemon did not answer" — a
467	// timeout story about a path that was doomed at parse. Refusing here	463	// timeout story about a path that was doomed at parse. Refusing here
468	// costs nothing and says the real thing.	464	// costs nothing and says the real thing.
@@ -813,9 +809,9 @@ test "parseArgs: --sock and --via each name their transport" {
813	try std.testing.expectEqualStrings("/tmp/x.sock", s.attach.sock.?);	809	try std.testing.expectEqualStrings("/tmp/x.sock", s.attach.sock.?);
814	try std.testing.expect(s.attach.via == null);	810	try std.testing.expect(s.attach.via == null);
815		811
816	const v = try parse(&.{ "mux", "--via", "ssh box muxd proxy" });	812	const v = try parse(&.{ "mux", "--via", "ssh box mux d proxy" });
817	try std.testing.expect(v == .attach);	813	try std.testing.expect(v == .attach);
818	try std.testing.expectEqualStrings("ssh box muxd proxy", v.attach.via.?);	814	try std.testing.expectEqualStrings("ssh box mux d proxy", v.attach.via.?);
819	try std.testing.expect(v.attach.sock == null);	815	try std.testing.expect(v.attach.sock == null);
820	}	816	}
821		817
@@ -839,7 +835,7 @@ test "parseArgs: a bare word is a host to hop to" {
839	test "parseArgs: naming two transports is a conflict, however it is spelled" {	835	test "parseArgs: naming two transports is a conflict, however it is spelled" {
840	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "vm1", "--sock", "/tmp/x.sock" }));	836	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "vm1", "--sock", "/tmp/x.sock" }));
841	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "--sock", "/tmp/x.sock", "vm1" }));	837	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "--sock", "/tmp/x.sock", "vm1" }));
842	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "vm1", "--via", "ssh box muxd proxy" }));	838	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "vm1", "--via", "ssh box mux d proxy" }));
843	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "--sock", "/a", "--via", "c" }));	839	try std.testing.expectError(error.Conflict, parse(&.{ "mux", "--sock", "/a", "--via", "c" }));
844	// Two of the same kind is the same ambiguity as two different kinds —	840	// Two of the same kind is the same ambiguity as two different kinds —
845	// for the two spellings that carry no flag. A flag repeated is not	841	// for the two spellings that carry no flag. A flag repeated is not
@@ -1133,7 +1129,7 @@ test "parseArgs: --quic-idle-ms parses, and refuses what ngtcp2 would invert" {
1133		1129
1134	// A bare HOST ends in a QUIC link too, so the flag has to reach it —	1130	// A bare HOST ends in a QUIC link too, so the flag has to reach it —
1135	// the .host result carried no idle_ms at all and the flag was accepted	1131	// the .host result carried no idle_ms at all and the flag was accepted
1136	// and then dropped, which is worse than refusing it. muxweb's HOST	1132	// and then dropped, which is worse than refusing it. The hub's HOST
1137	// tiles were already right; this is mux catching up.	1133	// tiles were already right; this is mux catching up.
1138	const h = try parse(&.{ "mux", "vm1", "--quic-idle-ms", "1500" });	1134	const h = try parse(&.{ "mux", "vm1", "--quic-idle-ms", "1500" });
1139	try std.testing.expect(h == .host);	1135	try std.testing.expect(h == .host);

src/cli/muxa.zig

src/cli/webhub_main.zig

Old		New
@@ -53,7 +53,7 @@ pub fn parse(comptime T: type, dst: *T, args: []const [:0]const u8) Outcome {
53	// `--version` shares the pass for the same reason: asking a binary its	53	// `--version` shares the pass for the same reason: asking a binary its
54	// version must answer a line that would otherwise be refused.	54	// version must answer a line that would otherwise be refused.
55	// It stops at `--` because past that point the words are payload: a	55	// It stops at `--` because past that point the words are payload: a
56	// `muxa send -- --help` types `--help` AT a session, and a usage page	56	// `mux a send -- --help` types `--help` AT a session, and a usage page
57	// instead of the keystrokes would be the parser answering for the user.	57	// instead of the keystrokes would be the parser answering for the user.
58	for (args) \|a\| {	58	for (args) \|a\| {
59	if (std.mem.eql(u8, a, "--")) break;	59	if (std.mem.eql(u8, a, "--")) break;
@@ -292,11 +292,11 @@ test "flagName: underscores become dashes" {
292	}	292	}
293		293
294	test "documented: a prefix of a longer flag does not count" {	294	test "documented: a prefix of a longer flag does not count" {
295	try std.testing.expect(!documented("--sock", " muxd run [--socket PATH]\n"));	295	try std.testing.expect(!documented("--sock", " mux d run [--socket PATH]\n"));
296	try std.testing.expect(documented("--sock", " muxd run [--sock PATH]\n"));	296	try std.testing.expect(documented("--sock", " mux d run [--sock PATH]\n"));
297	try std.testing.expect(documented("--vt", " muxd dump [--vt]\n"));	297	try std.testing.expect(documented("--vt", " mux d dump [--vt]\n"));
298	try std.testing.expect(documented("--vt", " muxd dump --vt\n"));	298	try std.testing.expect(documented("--vt", " mux d dump --vt\n"));
299	try std.testing.expect(documented("--vt", " muxd dump --vt"));	299	try std.testing.expect(documented("--vt", " mux d dump --vt"));
300	try std.testing.expect(!documented("--rows", "nothing here\n"));	300	try std.testing.expect(!documented("--rows", "nothing here\n"));
301	}	301	}
302		302
@@ -305,7 +305,7 @@ test "assertDocumented: every visible flag is named in the prose" {
305	\\ demo [--vt] [--sock PATH] [--cols N] [--quic-idle-ms N]	305	\\ demo [--vt] [--sock PATH] [--cols N] [--quic-idle-ms N]
306	\\	306	\\
307	;	307	;
308	// `shell` stands in for muxd's machine-written flags: hidden from the	308	// `shell` stands in for the daemon's machine-written flags: hidden from the
309	// prose on purpose, so the assertion must not demand it.	309	// prose on purpose, so the assertion must not demand it.
310	comptime assertDocumented(Demo, text, &.{"shell"});	310	comptime assertDocumented(Demo, text, &.{"shell"});
311	}	311	}

Old		New
@@ -1,4 +1,4 @@
1	//! muxd — daemon entrypoint. `run` hosts the session; `dump` prints the	1	//! `mux d` — the daemon mode. `run` hosts the session; `dump` prints the
2	//! authoritative grid over the protocol (debug aid, also used by e2e);	2	//! authoritative grid over the protocol (debug aid, also used by e2e);
3	//! `proxy` exposes the session socket over stdio for `mux --via`.	3	//! `proxy` exposes the session socket over stdio for `mux --via`.
4	const std = @import("std");	4	const std = @import("std");
@@ -17,19 +17,19 @@ const cliflags = @import("cliflags");
17		17
18	const usage =	18	const usage =
19	\\usage:	19	\\usage:
20	\\ muxd run [--sock PATH] [--shell PATH] [--cols N] [--rows N]	20	\\ mux d run [--sock PATH] [--shell PATH] [--cols N] [--rows N]
21	\\ [--quic HOST[:PORT] --key FILE] [--quic-idle-ms N]	21	\\ [--quic HOST[:PORT] --key FILE] [--quic-idle-ms N]
22	\\ muxd dump [--vt] [--session NAME] [--sock PATH]	22	\\ mux d dump [--vt] [--session NAME] [--sock PATH]
23	\\ muxd stats [--sock PATH]	23	\\ mux d stats [--sock PATH]
24	\\ muxd stop [--sock PATH] (ask the daemon on PATH to exit)	24	\\ mux d stop [--sock PATH] (ask the daemon on PATH to exit)
25	\\ muxd proxy [--sock PATH] (byte pump: stdio <-> session socket)	25	\\ mux d proxy [--sock PATH] (byte pump: stdio <-> session socket)
26	\\ muxd endpoint [--sock PATH] (proxy that first announces QUIC port+key)	26	\\ mux d endpoint [--sock PATH] (proxy that first announces QUIC port+key)
27	\\ muxd keygen (write a fresh key to ~/.config/mux/key)	27	\\ mux d keygen (write a fresh key to ~/.config/mux/key)
28	\\ muxd start [run's flags] (spawn a daemon detached; no-op if one is up)	28	\\ mux d start [run's flags] (spawn a daemon detached; no-op if one is up)
29	\\ muxd upgrade [--sock PATH] (exec THIS binary over the daemon; sessions live)	29	\\ mux d upgrade [--sock PATH] (exec THIS binary over the daemon; sessions live)
30	\\ [--allow-same-version] (strictly newer, unless this; the e2e leg's)	30	\\ [--allow-same-version] (strictly newer, unless this; the e2e leg's)
31	\\ muxd --version	31	\\ mux d --version
32	\\ muxd --help	32	\\ mux d --help
33	\\	33	\\
34	;	34	;
35		35
@@ -62,7 +62,7 @@ const Spec = struct {
62	/// returns before the loop, so nothing after the name is read.	62	/// returns before the loop, so nothing after the name is read.
63	///	63	///
64	/// `ignored` is a contract, not an oversight: trailing arguments are	64	/// `ignored` is a contract, not an oversight: trailing arguments are
65	/// ACCEPTED and vanish silently. `muxd --version` with an over-long	65	/// ACCEPTED and vanish silently. `mux d --version` with an over-long
66	/// `--sock` exits 0 today, pinned in e2e.sh ("--version refused over	66	/// `--sock` exits 0 today, pinned in e2e.sh ("--version refused over
67	/// sock length"). Narrowing it to `none` would turn that into a	67	/// sock length"). Narrowing it to `none` would turn that into a
68	/// refusal.	68	/// refusal.
@@ -236,10 +236,10 @@ fn usageExit(u: Usage) u8 {
236	.no_command => std.debug.print("{s}", .{usage}),	236	.no_command => std.debug.print("{s}", .{usage}),
237	.unknown_command => std.debug.print("{s}", .{usage}),	237	.unknown_command => std.debug.print("{s}", .{usage}),
238	.unknown_arg => \|a\| std.debug.print("unknown argument: {s}\n{s}", .{ a, usage }),	238	.unknown_arg => \|a\| std.debug.print("unknown argument: {s}\n{s}", .{ a, usage }),
239	.missing_value => \|f\| std.debug.print("muxd: {s} needs a value\n{s}", .{ f, usage }),	239	.missing_value => \|f\| std.debug.print("mux d: {s} needs a value\n{s}", .{ f, usage }),
240	.bad_value => \|f\| std.debug.print("muxd: {s} was given a value it cannot hold\n{s}", .{ f, usage }),	240	.bad_value => \|f\| std.debug.print("mux d: {s} was given a value it cannot hold\n{s}", .{ f, usage }),
241	.key_without_quic => std.debug.print(	241	.key_without_quic => std.debug.print(

Old		New
@@ -1,4 +1,4 @@
1	//! muxa: the agent-facing mux client. Every verb prints one JSON object on	1	//! `mux a`: the agent-facing mode. Every verb prints one JSON object on
2	//! stdout and exits 0 on success; failures print {"error": "..."} and exit	2	//! stdout and exits 0 on success; failures print {"error": "..."} and exit
3	//! nonzero. Attaches at 0x0 always — an agent must never claim the grid	3	//! nonzero. Attaches at 0x0 always — an agent must never claim the grid
4	//! out from under the human's size (load-bearing spec rule).	4	//! out from under the human's size (load-bearing spec rule).
@@ -11,7 +11,7 @@
11	//! 3 the wait timed out; the object says `"reason":"timeout"`	11	//! 3 the wait timed out; the object says `"reason":"timeout"`
12	//! 4 the object could not be written at all (see `emit`)	12	//! 4 the object could not be written at all (see `emit`)
13	//!	13	//!
14	//! A command's own exit code is never muxa's: it is the `exit_code` field,	14	//! A command's own exit code is never this mode's: it is the `exit_code` field,
15	//! and a `run` whose command failed still exits 0 because the question was	15	//! and a `run` whose command failed still exits 0 because the question was
16	//! answered.	16	//! answered.
17	const std = @import("std");	17	const std = @import("std");
@@ -24,10 +24,10 @@ const cliflags = @import("cliflags");
24	const build_options = @import("build_options");	24	const build_options = @import("build_options");
25		25
26	const usage =	26	const usage =
27	\\usage: muxa <verb> [--sock PATH \| --quic HOST[:PORT] [--key PATH]]	27	\\usage: mux a <verb> [--sock PATH \| --quic HOST[:PORT] [--key PATH]]
28	\\ [--settle MS] [--timeout MS] [--vt] [--session NAME] [args]	28	\\ [--settle MS] [--timeout MS] [--vt] [--session NAME] [args]
29	\\ muxa --help \| --version	29	\\ mux a --help \| --version
30	\\NAME must already exist: muxa attaches at 0x0 and never creates a session	30	\\NAME must already exist: `mux a` attaches at 0x0 and never creates a session
31	\\(`capture` is the exception that stays quiet: it answers in the grid).	31	\\(`capture` is the exception that stays quiet: it answers in the grid).
32	\\verbs:	32	\\verbs:
33	\\ status session snapshot as JSON	33	\\ status session snapshot as JSON
@@ -53,7 +53,7 @@ const Opts = struct {
53	key: ?[]const u8 = null,	53	key: ?[]const u8 = null,
54	settle: u32 = 0,	54	settle: u32 = 0,
55	// Never 0 by default: the daemon reads a 0 timeout on await_req as "no	55	// Never 0 by default: the daemon reads a 0 timeout on await_req as "no
56	// bound at all" (documented on AwaitReq), so a muxa that defaulted to 0	56	// bound at all" (documented on AwaitReq), so an agent client that defaulted to 0
57	// would turn every await into an unbounded wait.	57	// would turn every await into an unbounded wait.
58	timeout: u32 = 30_000,	58	timeout: u32 = 30_000,
59	vt: bool = false,	59	vt: bool = false,
@@ -69,7 +69,7 @@ const Opts = struct {
69	// ONE name for the attach AND every ask after it, so the daemon's	69	// ONE name for the attach AND every ask after it, so the daemon's
70	// attached-tail equality rule (server.zig) never sees a mismatch	70	// attached-tail equality rule (server.zig) never sees a mismatch
71	// out of this binary. Empty is the wire's own default spelling, so	71	// out of this binary. Empty is the wire's own default spelling, so
72	// a bare `muxa status` builds the frames it always did.	72	// a bare `mux a status` builds the frames it always did.
73	return if (o.session) \|n\| n.name else "";	73	return if (o.session) \|n\| n.name else "";
74	}	74	}
75		75

Old		New
@@ -1,4 +1,4 @@
1	//! muxweb — the hub binary. `muxweb [TARGET ...]	1	//! `mux web` — the hub mode. `mux web [TARGET ...]
2	//! [--port N]`: serves the wall page on 127.0.0.1 and pumps one	2	//! [--port N]`: serves the wall page on 127.0.0.1 and pumps one
3	//! WebSocket per tile, dialing each TARGET the way the mux CLI does.	3	//! WebSocket per tile, dialing each TARGET the way the mux CLI does.
4	//! TARGET spellings are mux's own: bare HOST (ssh→QUIC handoff),	4	//! TARGET spellings are mux's own: bare HOST (ssh→QUIC handoff),
@@ -24,7 +24,7 @@ const sockpath = @import("sockpath");
24	const cliflags = @import("cliflags");	24	const cliflags = @import("cliflags");
25		25
26	const usage =	26	const usage =
27	\\usage: muxweb [TARGET[#SESSION] ...] [--port N]	27	\\usage: mux web [TARGET[#SESSION] ...] [--port N]
28	\\ each TARGET is a tile: HOST \| --sock PATH \| quic://HOST[:PORT]	28	\\ each TARGET is a tile: HOST \| --sock PATH \| quic://HOST[:PORT]
29	\\ `--sock PATH` may be two arguments or one quoted '--sock PATH', the	29	\\ `--sock PATH` may be two arguments or one quoted '--sock PATH', the
30	\\ spelling the wall file holds; `mux wall` takes both too	30	\\ spelling the wall file holds; `mux wall` takes both too
@@ -89,7 +89,7 @@ fn parseArgs(
89	// targets on the line, `usage` alone would not say which.	89	// targets on the line, `usage` alone would not say which.
90	if (p._argv.err) \|e\| {	90	if (p._argv.err) \|e\| {
91	if (e.err == error.OutOfMemory) return error.OutOfMemory;	91	if (e.err == error.OutOfMemory) return error.OutOfMemory;
92	std.debug.print("muxweb: tile {s}: {s}\n", .{ e.word, wall.reason(e.err) });	92	std.debug.print("mux web: tile {s}: {s}\n", .{ e.word, wall.reason(e.err) });
93	return error.Usage;	93	return error.Usage;
94	}	94	}
95	switch (outcome) {	95	switch (outcome) {
@@ -111,22 +111,20 @@ fn parseArgs(
111	return p;	111	return p;
112	}	112	}
113		113
114	pub fn main() !u8 {	114	/// `mux web`. argv is the dispatcher's, minus the program name.
		115	pub fn main(args: []const [:0]const u8) !u8 {
115	var gpa: std.heap.DebugAllocator(.{}) = .init;	116	var gpa: std.heap.DebugAllocator(.{}) = .init;
116	defer if (gpa.deinit() == .leak)	117	defer if (gpa.deinit() == .leak)
117	std.debug.print("muxweb: LEAK: allocations outlived deinit\n", .{});	118	std.debug.print("mux web: LEAK: allocations outlived deinit\n", .{});
118	const alloc = gpa.allocator();	119	const alloc = gpa.allocator();
119		120
120	const args = try std.process.argsAlloc(alloc);
121	defer std.process.argsFree(alloc, args);
122
123	var parsed = parseArgs(alloc, args, std.posix.getenv(xdg.key_env)) catch \|err\| switch (err) {	121	var parsed = parseArgs(alloc, args, std.posix.getenv(xdg.key_env)) catch \|err\| switch (err) {
124	error.Usage => {	122	error.Usage => {
125	std.debug.print("{s}", .{usage});	123	std.debug.print("{s}", .{usage});
126	return 2;	124	return 2;
127	},	125	},