90 Commits

This Branch

This Branch

All Branches

Author	SHA1	Message	Date
UltradesuandClaude Opus 4.8	eac54f8c79	Revert the GitHub workflow guard to server_url ... Misdiagnosed the earlier report: Gitea was correctly running its own .gitea/workflows copy, not this .github one, so the server_url guard was fine. The switch to a GITHUB_RELEASE repo variable then made the workflow skip on GitHub itself, since that variable is not set there. Put both job guards back to `github.server_url == 'https://github.com'`, which runs on GitHub with no manual setup and skips on Gitea (its .gitea copy is the one that runs). No repository variable is needed. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.8	2026-10-02 12:53:26 +01:00
UltradesuandClaude Opus 4.8	a8dfd7017b	Gate the GitHub release workflow on a repo variable, not server_url ... The github.server_url guard did not keep this workflow from running on Gitea: Gitea reports github.server_url as https://github.com, so the condition was true there too and the jobs ran (and would fail on @v4/gh). Switch both job guards to `vars.GITHUB_RELEASE == 'true'`, a repository variable set only in the GitHub repo's settings. It is deterministic: absent on Gitea, so the jobs skip there and the .gitea workflow is the one that runs; present on GitHub once configured, so it runs there. The header documents how to set it (Settings → Secrets and variables → Actions → Variables → GITHUB_RELEASE=true). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.7	2026-10-02 12:50:04 +01:00
UltradesuandClaude Opus 4.8	99f4cf0220	Add a GitHub release workflow alongside the Gitea one ... Gitea and GitHub need different release plumbing, so each gets its own file: the Gitea workflow stays in .gitea/workflows, and this GitHub one lives in .github/workflows. The build half is identical (static musl Linux via cargo-zigbuild, native macOS aarch64 and Windows x86_64); only publishing differs — GitHub uses the v4 artifact backend and `gh release create`/`upload`, which the Gitea file cannot use. Because Gitea reads both .gitea/workflows and .github/workflows, every job here is guarded with `if: github.server_url == 'https://github.com'`, so on Gitea this file's jobs are skipped (no v4/gh failures) and the .gitea file is the one that runs. GitHub never reads .gitea, so there it runs only this one. Publish is re-run safe: it creates the release on the first run and uploads with --clobber onto an existing release afterwards; a pre-release suffix on the tag marks it prerelease. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.6	2026-10-02 12:47:19 +01:00
UltradesuandClaude Opus 4.8	69263b2dd9	Move the release workflow to .gitea/workflows ... The release pipeline is Gitea-specific (v3 artifacts, Gitea release API), so it must not run on github.com, where it would fail. GitHub only reads .github/workflows, while Gitea reads both, so moving the file to .gitea/workflows keeps it running on Gitea and invisible to GitHub. A separate GitHub-flavoured release workflow can be added under .github later. The portable .github/workflows/ci.yml (fmt/clippy/test) is left in place; it works on both and is not what this change is about. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.5	2026-10-02 12:13:45 +01:00
UltradesuandClaude Opus 4.8	20444013c0	Split release into build artifacts + a publish job (Gitea) ... The direct-upload-from-each-build approach failed ("Upload the archive to the release" exit 1) and left no artifacts to inspect. Restructured into the familiar shape: build jobs now leave their archive as a run artifact, and a single publish job — gated on all targets succeeding — collects them and fills the release. - Build jobs use actions/upload-artifact@v3 (Gitea has no v4 backend; v3 is what shows under the run), so the archive is visible and handed on. - publish (needs: build) downloads everything with download-artifact@v3 and uploads each archive to the Gitea release with curl, once, with no matrix race. It prints the API base and the HTTP status/body of every call, so a failure (e.g. a read-only Actions token → 403, or a bad API URL) is now visible in the log instead of a bare exit 1. - Release API base prefers GITHUB_API_URL (Gitea sets it to its /api/v1 root) and falls back to GITHUB_SERVER_URL/api/v1. Asset uploads run in the main shell via process substitution so a failed upload fails the job. Build, package, musl/zig setup and the target matrix are unchanged. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-10-02 12:12:53 +01:00
UltradesuandClaude Opus 4.8	2196f6635b	Quiet the cosmetic zig linker_messages warning on the musl build ... The musl release build now links cleanly through cargo-zigbuild, but rustc's new linker_messages lint echoed zig's "ignoring deprecated linker optimization setting '1'" note — zig's linker declining the -O1 GNU-ld flag Rust passes. It is cosmetic and the binary is correct, so allow that one lint, scoped to the zig build step only. macOS and Windows keep full linker diagnostics, and a real link error still fails the build. No behaviour change to the produced binaries; takes effect on the next tag. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-10-02 12:06:04 +01:00
UltradesuandClaude Opus 4.8	6438982d45	Upload release assets via the Gitea API instead of artifacts + gh ... The release ran on Gitea Actions, where it failed at actions/upload-artifact@v4: the v4 artifact backend (and the GitHub REST API that `gh release create` uses) are not available on Gitea/GHES, so both the artifact handoff and the publish job were dead ends there. Reworked so each build job uploads its archive straight to the release through Gitea's native API (`/api/v1/repos/<repo>/releases`) with curl: create the release for the tag if absent (races between matrix jobs are resolved by reading the id back by tag), then POST the archive as an asset. The separate publish job, download-artifact and `gh` are gone. The id is parsed with grep, so the runner needs only curl and coreutils — no jq, no third-party release action. Uses the Gitea-injected GITHUB_TOKEN, GITHUB_SERVER_URL and GITHUB_REPOSITORY; a tag with a pre-release suffix (e.g. -rc.2) is marked prerelease. This targets Gitea by design; it no longer runs as-is on github.com (different API), which is fine — the GitHub build is being retired. Build and package steps, the musl/zig setup and the target matrix are unchanged. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.3	2026-10-02 12:04:20 +01:00
UltradesuandClaude Opus 4.8	21b619388c	Pin Zig to a real release so the musl release build fetches reliably ... The release run failed at "Install zig": mlugg/setup-zig, left unpinned, resolved to the newest version it knew of — an unreleased 0.16.0 whose tarball 404s on ziglang.org — and the community mirrors returned 502/503 around it, so the step errored out before cargo-zigbuild ever ran. Pin the action to Zig 0.14.1, an archived release with a permanent official download URL. The official source then succeeds even when the mirrors are flaky, and the version stays compatible with cargo-zigbuild. Also moves the action to @v2. Only the Linux musl jobs use zig; macOS and Windows are unaffected. Not run on a real tag yet in this session. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.2	2026-10-02 11:54:29 +01:00
UltradesuandClaude Opus 4.8	d1ab993dd2	Add a tagged-release CI workflow and Linux/Windows packaging ... Pushing a `v*` tag now builds the agent for every supported target and attaches the archives to a GitHub release. Modelled on the furumi release workflow (a build matrix, then a publish job that runs `gh release create`), adapted to this project's two differences: it needs system integration (capabilities/polkit on Linux, elevation+wintun on Windows, a root daemon on macOS), and its users run varied distros, not just Ubuntu. Linux is built as a fully **static musl** binary with cargo-zigbuild, so one artifact runs on Arch, Alpine, NixOS and old-glibc systems alike, and can be repackaged into whatever a distro prefers later. musl has no prebuilt aws-lc-sys bindings, so the Linux jobs install cmake + libclang (bindgen) and zig (the cross C compiler zigbuild drives). macOS (aarch64) and Windows (x86_64) build natively; Linux covers x86_64 and aarch64. Targets: x86_64/aarch64 linux-musl, aarch64 macOS, x86_64 Windows. Each archive carries the binary, the top-level README, and the platform's install notes plus integration files: - dist/linux/: a static-friendly README, a systemd unit (runs as root, so no capability grant or polkit rule is needed; a commented non-root variant is included), and an install.sh that drops the binary and the unit or prints the setcap/polkit alternative. - dist/windows/: install notes covering wintun.dll and Run-as-administrator. - dist/macos/: the existing LaunchDaemon plist and notes, now also shipped in the archive. Not exercised yet: the workflow only runs on a real tag push, and the aws-lc-sys-under-musl build has not been run locally in this session (no zig toolchain here). YAML and install.sh syntax are validated. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> v0.1.0-rc.1	2026-10-02 11:48:19 +01:00
UltradesuandClaude Opus 4.8	da7ce1dca1	Drop link-local addresses from the status "not announced" list ... A host with several interfaces has a link-local (fe80::/10, and 169.254/16 on IPv4) on each, and none of them is ever a peer candidate. Listing them under "not announced" padded the section with one noise line per interface — most of the list on a machine with several VPN utuns. They are now filtered out; loopback and real unannounced addresses are unaffected. Checks: cargo fmt --all --check and cargo clippy -p tsunagi-cli --all-targets -D warnings pass; verified by eye against a live `tsunagi status`. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-10-02 11:38:21 +01:00
UltradesuandClaude Opus 4.8	4d2f8a54ec	Compact the status address list to one line per address ... `tsunagi status` printed every local address as two lines: the address, then an indented note holding the interface (and, for candidates, a priority rank). On a host with many interfaces — common on macOS, where each VPN adds a utun and every interface carries a link-local — that made the "local addresses" section very long and hard to scan. Each address is now a single line: the announce status stays the label (announced / not announced / loopback) and the address and its interface share the detail, as `<addr> · <iface>`. The per-row note and the candidate-priority rank are dropped; ordering still reflects candidate priority. No other section changes, and nothing but the presentation does. Checks: cargo fmt --all --check, cargo clippy --locked --workspace --all-targets -D warnings, and the tsunagi-cli tests all pass on macOS; verified by eye against a live `tsunagi status`. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-10-02 11:26:13 +01:00
UltradesuandClaude Opus 4.8	c3a6201ee2	Bring the macOS stack up: utun interface, resolver files, system paths ... macOS was TUN-less: the agent ran only with `--no-tun`, so tunnels formed but nothing reached the operating system. The provisioner, host rules and DNS publisher had Linux and Windows implementations and fell through to the unsupported/erroring paths on macOS. This adds the macOS half so `tsunagi up` carries real traffic there. The shared decision logic (plan_changes, rules_summary, Published) is untouched — only the per-platform mechanics are new. What it does on macOS (all root-only; macOS has no per-capability grant): - Interface: a `utun` device opened over the in-kernel utun control socket via the existing `tun` dependency (no kext, no Network Extension). The kernel assigns the `utunN` name, so a name derived from the network id is not a legal utun name; `open_tun` leaves the name unset on macOS and reads the real one back, and `Interface::start` adopts `device.name()` as the name everything downstream configures (host rules, reconfigure). A utun is torn down with the process, so a crash never leaks one. Addresses, MTU, up and the overlay subnet route are applied with `/sbin/ifconfig` and `/sbin/route` (absolute paths, args built only from locally-derived values), the same role netlink plays on Linux and netsh on Windows. Observation is `netdev` (getifaddrs). - DNS: a resolver-dir publisher writes `/etc/resolver/<network>` files pointing the system resolver at the overlay DNS server for each zone. The files carry a `port`, so the server needs no privileged socket, and a marker line, so the publisher only ever replaces or removes files it wrote and never clobbers a user's own. Removed on revert. - Broadcast host rules: the `255.255.255.255` route is installed with `route`. The inbound-UDP firewall allowance (a pf anchor) is deferred and reported as the incomplete half, so `status` says what to allow by hand; the route still goes in. Failure stays contained, exactly as on the other platforms. - Privilege: probe is optimistic (like Windows); the honest answer comes from the utun open, whose permission error now says to run with sudo or as a daemon. Deployment: - Default paths on macOS are fixed system locations rather than per-user Library dirs, so they do not depend on whose shell ran sudo: state `/var/db/tsunagi`, cache `/var/db/tsunagi/cache` (StoragePaths::user_default), control socket `/var/run/tsunagi/agent.sock` (default_control_socket_path, mirroring the Windows %ProgramData% branch). The local control socket already uses the shared `unix` adapter, so no IPC changes were needed — macOS is Unix. - dist/macos/ carries a root LaunchDaemon plist and install notes; README's deployment section now documents the macOS path instead of "not implemented". Decisions (agreed up front): utun auto-assign with the real name adopted; ifconfig/route rather than raw PF_ROUTE/ioctl (which would need unsafe); /etc/resolver files rather than scutil; route-now/firewall-deferred; root via sudo or a LaunchDaemon rather than Network Extension (which would require a signed sandboxed app bundle, not a Rust CLI). Checks: on macOS (Darwin 27), `cargo fmt --all --check`, `cargo clippy --locked --workspace --all-targets -D warnings`, and `cargo test --locked --workspace --all-targets` all pass (0 failures); the new macos-gated unit tests run under the standard workspace command via feature unification. Not yet exercised live: actual utun creation, ifconfig/route application and /etc/resolver writes need a root run, which has not been done in this session. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-10-02 11:15:59 +01:00
Aleksandr Bogomiakov	533921059a	Install broadcast route and firewall allowance on the host while broadcast is on ... LAN discovery (CS 1.6 and similar) only worked after two manual steps on every host: route 255.255.255.255 through the TUN, and allow inbound traffic on it. Without the route the game's limited broadcast leaves via the physical adapter and never reaches the overlay; without the firewall allowance the server's unicast reply (from a different address than the one the request went to, so never matched by conntrack) is dropped before the game's socket. Verified by hand on Linux: with both in place the server answered A2S_INFO over the overlay. The system level (not a plugin) now installs exactly those two things for the interface it owns, and removes them when broadcast is turned off, the network is left or stopped, or the agent exits. Design: - New boundary overlay::hostrules (BroadcastHostRules: idempotent apply/clear, with Linux, Windows, Mock and Unsupported implementations). TunFactory gains host_rules(); ManagedTunFactory::with_host_rules wires it in the CLI. - Interface::sync_broadcast_rules reconciles the host against the routing table (RoutingTable::broadcast_host_target) and is called after address sync, on live `network broadcast on/off`, on network deactivation and by remove(). Failure is contained: the outcome is kept and logged, never fatal. - One interface carries several networks but the host has one 255.255.255.255 route, so the source is the lowest NetworkId among broadcast-enabled networks with an address (documented in docs/broadcast.md). - Linux: the route is added on the existing netlink thread (preferred source = overlay address, replace semantics). The firewall rule is `iptables -I INPUT -i <if> -p udp -s <overlay range>` tagged with a comment `tsunagi:<if>`; it is UDP-only and range-limited on purpose so TCP services stay unexposed. iptables is located in fixed system directories, never via PATH; stale tagged rules (e.g. from a crash) are replaced. A missing iptables leaves the route in place and is reported. rp_filter is not touched. - Windows: PowerShell (absolute path) New-NetRoute metric 1 and a tagged inbound UDP Defender rule scoped to the interface alias and overlay range. - status shows a `broadcast rules` row (ok, or which half failed and why). IPC control protocol bumped 14 -> 15 because OverlayReport gained a field. - AGENTS.md records the narrow exception to "never touch routing/firewall". Compatibility: restart the agent after upgrading (control protocol 15). No wire or schema change. Checks run (Linux only): cargo fmt --check, cargo clippy --locked --workspace --all-targets -D warnings, cargo test --locked --workspace --all-targets, all passing. Tests use a mock host and a scripted iptables; no OS setting is changed. NOT done: the Windows code was never compiled for or run on Windows (cross-compiling failed for lack of a C toolchain), only its script building is unit-tested; the real netlink route and iptables calls were not exercised against a live kernel in the suite; CS 1.6 was not launched from this change.	2026-10-01 15:03:43 +01:00
Aleksandr Bogomiakov	d2778f0b5a	Prevent WireGuard timer loop failure spam and fix handshake broadcast ... When a WireGuard tunnel handshake timed out or a rekey failed, Inner::on_tunnel_failed closed the transport link and reported the failure to the agent core. However: 1. The peer remained in WireguardDevice::inner.peers. Once boringtun declared ConnectionExpired (after 90s), self.tunn.is_expired() remained permanently true on all subsequent 250ms timer ticks. drive_timers repeatedly detected failed = true every 250ms, flooding logs with 'WARN WireGuard tunnel failed due to rekey timeout, triggering fallback' and sending repeated protocol failure events to the core 4 times/sec. 2. In WireguardLink::send, is_handshake_init incorrectly expected an envelope header offset (msg[74] == 1) when checking for initiation packets, which failed on raw WireGuard UDP packets. As a result, handshake initiations were not broadcast to all candidate endpoints. 3. In WireguardTransport::accept_loop, packet source matching contained dead envelope destination matching inspecting ephemeral key bytes against local endpoint IDs. Fixes: - In crates/tsunagi-wireguard/src/device.rs: - Add failed: bool to FlowTunnel to latch failure state. Once a failure is reported, update_timers returns (TunnResult::Done, false) on all subsequent ticks until a new handshake is started or completed. - In Inner::on_tunnel_failed, remove the failed peer from inner.peers so drive_timers ceases ticking on the dead tunnel. - In crates/tsunagi-wireguard/src/plugin.rs: - In Worker::sync, retain only active unclosed links in state.links. - In crates/tsunagi-wireguard/src/transport.rs: - Check is_handshake_init directly as '!msg.is_empty() && msg[0] == 1', ensuring handshake initiations are broadcast to all candidate addresses. - Clean up matched_peer to look up links and peer candidate addresses directly. - Tests: - Update test_flow_tunnel_rekey_timeout_triggers_failure to assert failure latching and verify no repeated failure reports on subsequent ticks. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed. - cargo build --release passed.	2026-10-01 03:18:32 +01:00
Aleksandr Bogomiakov	8cfece9479	Filter noisy internal warnings from boringtun and iroh net_report ... The CLI's default tracing filter previously allowed WARN level logs from boringtun and iroh, producing two confusing and noisy log messages during routine operation: 1. 'WARN HANDSHAKE(REJECT_AFTER_TIME - KEEPALIVE_TIMEOUT - REKEY_TIMEOUT (on receive))': emitted by boringtun's internal timer tick when an endpoint primarily receives data for 165 seconds (180s - 10s - 5s). In boringtun, this is a routine scheduled rekey timer rather than an error or failure, but was unhelpfully logged as warn! upstream. 2. 'WARN probe timed out': emitted by iroh's net_report module during background HTTP captive portal detection when running in isolated subnets or VMs without direct internet access. This probe has no impact on mesh connectivity. Update the default logging filter to: 'info,iroh=warn,iroh::net_report=error,quinn=warn,rustls=warn,boringtun=error,mainline=off' Real WireGuard handshake and rekey failures continue to be detected and reported cleanly by Tsunagi's own data plane diagnostics and automatic fallback handlers at INFO and WARN levels. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed. - cargo build --release passed.	2026-10-01 03:06:20 +01:00
Aleksandr Bogomiakov	3930dff2dc	Detect WireGuard tunnel rekey failure and trigger automatic fallback ... Previously, because UDP is connectionless, when a pure WireGuard tunnel encountered handshake or rekey failures (e.g. boringtun logging `WARN HANDSHAKE(REKEY_TIMEOUT)` and `CONNECTION_EXPIRED`), the `WireguardLink` never closed. It remained active in `agent.links` and as a direct hop in `RelayHub.raw`. Consequently, outgoing packets continued to be blackholed over the dead direct path, preventing `RelayHub` from using working multihop relay routes and preventing the agent from falling back to alternative protocols (`tcp-tls` or `wg-quic`). Key changes: - In `crates/tsunagi-wireguard/src/device.rs`: - In `FlowTunnel`, track active handshake and rekey attempts via `handshake_started_at`. If an active handshake attempt remains unanswered beyond `HANDSHAKE_TIMEOUT` (15s) or boringtun reports `ConnectionExpired`, declare the tunnel dead. - Reset timeout timers upon successful handshake reception in `decapsulate`. - In `drive_timers`, when tunnel failure is detected, trigger `inner.on_tunnel_failed(peer)`, which closes the direct transport link and notifies the agent via `PluginContext::report_peer_protocol_failure`. - In `crates/tsunagi-wireguard/src/transport.rs`: - Add `WireguardLink::close` to transition `is_closed` to true and notify `closed_notify`. - In `WireguardLink::recv`, select on `closed_notify` so readers unblock and return `None` immediately on close. - Add `WireguardTransport::close_link` to close active links by network and peer. - In `crates/tsunagi/src/dataplane/mod.rs`: - Add `PluginRequest::ProtocolFailure` and public helper `PluginContext::report_peer_protocol_failure`. - In `crates/tsunagi/src/agent/mod.rs` and `crates/tsunagi/src/agent/network.rs`: - Add `NetCommand::ProtocolFailure` to runtime command handling. - On protocol failure: remove dead direct link from `self.links`, clear it from `RelayHub.raw` (so `RelayHub` immediately routes over available multihop relays), record failure on `wg` for that peer with exponential backoff cooldown, emit `DataLinkDown`, and immediately call `ensure_links()` to dial the next mutually supported protocol (`tcp-tls` or `wg-quic`). - Tests: - Add `test_flow_tunnel_rekey_timeout_triggers_failure` and `test_flow_tunnel_reset_on_handshake` unit tests in `device.rs`. - Add `test_wireguard_link_close_and_transport_close_link` in `transport_tests.rs`. - Add `test_protocol_dial_state_cooldown_and_fallback_selection` in `network.rs`. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (350+ tests passed). - Built release binary: target/release/tsunagi.	2026-10-01 03:02:09 +01:00
Aleksandr Bogomiakov	35acc4d231	Fix WireGuard relay preemption with UDP probing, allow VM bridges, and categorize status addresses ... When remote peers communicate across networks with mixed connectivity (e.g. a remote Linux node, a local Linux host, and a Windows VM guest under KVM): - Previously, `WireguardTransport` immediately created and installed unverified direct links into `RelayHub` in `notify_peer_capability` and `open()`. When a remote peer had only unroutable private addresses (e.g. 192.168.122.151 on a KVM NAT bridge), this dead direct link preempted the working 2-hop relay, causing packet drops, failed handshakes, and REKEY_TIMEOUT errors. - Host-guest VM bridges (`virbr*`) were previously filtered out, preventing the VM guest from discovering the host's bridge IP (192.168.122.1) and forcing it to attempt cross-interface connections to host Wi-Fi/LAN. - Concurrent activation of multiple networks sharing one `tsun0` interface raced in `sync_addresses`, resulting in netlink `File exists (os error 17)` and `The object already exists` on Windows. Key fixes: - In `crates/tsunagi-wireguard/src/transport.rs`: - Implement bidirectional UDP probing with `TSUNAGI_WG_PROBE_V1` PING/PONG. - In `open()`, probe candidate endpoints with retransmission up to 1200ms. If unreachable, return `TransportError::Unreachable`, preventing dead links from preempting valid relay routes in `RelayHub`. - In `notify_peer_capability`, send hole-punching probes without prematurely installing unverified links. - In `accept_loop`, reply to PING probes with PONG and install confirmed inbound links targeting the verified source address. - In `WireguardLink::send`, inspect byte 74 of enveloped packets to detect handshake initiations, ensuring confirmed links route data packets only to the active target. - In `crates/tsunagi-wireguard/src/plugin.rs`: - Permit VM bridges (`virbr*`) as candidate interfaces (priority 10). - Add `prioritize_local_subnet` to prioritize candidates sharing a local IPv4 subnet with the receiver (e.g. 192.168.122.0/24). - In `crates/tsunagi/src/overlay/interface.rs` & provisioners: - Add async mutex `sync_lock` to serialize concurrent address syncs across networks. - Handle netlink EEXIST (os error 17) and Windows already-exists errors idempotently as success. - In `crates/tsunagi-cli/src/main.rs`: - Split `local addresses` in `tsunagi status` into `announced` (candidate addresses in priority order with interface and rank), `not announced` (container bridges/internal addresses with interface name), and `loopback`. - Tests: - Add `test_wireguard_transport_unreachable_probe_times_out` and `test_matches_subnet` unit tests. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (350+ tests passed).	2026-10-01 02:38:13 +01:00
Aleksandr Bogomiakov	c791102ad9	Fix overlay and virtual interface candidate leakage and WireGuard rekeying ... On Windows (Wintun), iface.name in netdev is an adapter GUID, while iface.friendly_name is 'tsun0'. Checking only iface.name failed to identify and exclude Wintun overlay interfaces. Consequently, Windows nodes announced their own overlay IP addresses (e.g. 10.13.37.26) as candidate endpoints. Remote peers latched onto this overlay IP as the WireGuard target, routing encrypted packets into tsun0 (recursive loop), resulting in failed handshakes and subsequent HANDSHAKE(REKEY_TIMEOUT) and CONNECTION_EXPIRED. Similarly, Docker bridges (br-*, docker0) and virtual bridges were announced and alphabetically sorted before physical LAN or Tailscale interfaces, causing peers to attempt WireGuard handshakes with internal Docker bridge addresses (e.g. 172.21.0.1). Key changes: - In crates/tsunagi-wireguard and crates/tsunagi-tcp-tls: - Robustly identify overlay interfaces by inspecting iface.name, iface.friendly_name, and iface.description for 'tsun', 'tsunagi', and 'wintun'. - Filter out container and virtual bridge interfaces (docker, br-, veth, virbr, cni, flannel, cali, kube, dummy, lxc, podman, vethernet, vboxnet, vmnet). - Prioritize candidates by physical interface score: interfaces with a default gateway (physical LAN/WAN) and Tailscale (100.64.0.0/10) score highest and sort to candidate #0. - In on_peer_capability, filter out any announced address falling inside any active overlay IPv4 range (defense in depth on receiver). - In crates/tsunagi-wireguard/src/transport.rs: - In WireguardLink::send, broadcast Handshake Initiation packets (type 1) to all candidate addresses so initial handshakes and rekeys probe all candidate paths and recover if an endpoint roamed or NAT expired. - In accept_loop, prioritize exact socket address matches before falling back to candidate IP matches for NAT port roaming. - In crates/tsunagi/src/net.rs: - Update iroh AddrFilter to inspect friendly_name and description, preventing Wintun overlay IPs from leaking into iroh discovery endpoints. - Tests: - Add unit tests for candidate interface filtering, IP validation, and priority scoring in tsunagi-wireguard and tsunagi-tcp-tls. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (350+ tests passed).	2026-10-01 02:15:06 +01:00
Aleksandr Bogomiakov	f80841da63	Fix WireGuard multi-network demux, candidate discovery, and status reporting ... When a peer belongs to multiple overlay networks served by one agent (e.g. a VM participating in both 'hexor' and 'ultradesu'), packets received on the shared WireGuard UDP socket could not be differentiated by source IP/port alone. Previously, `WireguardTransport::accept_loop` picked the first matching link found in iteration order, starving other networks for that peer and causing rekey timeouts (`WARN HANDSHAKE(REKEY_TIMEOUT)`, `ERROR CONNECTION_EXPIRED(REKEY_ATTEMPT_TIME)`) and packet loss on the starved network. Additionally: - When a peer had multiple candidate endpoints (such as LAN, VM bridge, and Tailscale CGNAT addresses), `WireguardLink` sent handshake initiations only to `addrs[0]`. If the first address was unreachable from the remote side (e.g. host's Tailscale IP unreachable from inside a local VM), the handshake never completed. - In `build_report`, peers known to the `wg-quic` plugin were added with empty tunnels even if an active `wg` (pure WireGuard) tunnel existed, causing `tsunagi status` to falsely report 'no WireGuard handshake yet' for connected and pingable peers. - `local_ip_candidates` previously included IPv6 addresses which caused OS error 22 (EINVAL) when passed to the IPv4-bound UDP socket. Key fixes: - In `crates/tsunagi-wireguard/src/transport.rs`: - Store `peer_networks` as `HashSet<NetworkId>` per peer. - In `WireguardLink`, maintain a list of candidate addresses and a `confirmed` flag. Before a handshake response confirms the active path, transmit datagrams (handshake initiations) to all candidate addresses. Upon receiving an inbound datagram, lock onto the confirmed address. - In `accept_loop`, deliver inbound datagrams to all active links associated with the sender's endpoint ID across all networks. Boringtun's cryptographic index and AEAD verification naturally demultiplexes and accepts the packet in the correct network while discarding it in others. - Filter candidate addresses to IPv4 to match the bound socket family. - In `crates/tsunagi-wireguard/src/plugin.rs`: - Only collect IPv4 interfaces in `local_ip_candidates`. - In `crates/tsunagi-cli/src/main.rs`: - Refactor `build_report` to evaluate all protocols per peer and prioritize whichever protocol has an active tunnel (`wg` > `tcp-tls` > `wg-quic`). - In `crates/tsunagi-wireguard/tests/plugin_tests.rs`: - Add `test_wireguard_two_networks_same_peers` verifying simultaneous bidirectional packet transmission between two peers sharing two networks over a single `WireguardTransport`. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (350+ tests passed).	2026-10-01 01:38:44 +01:00
Aleksandr Bogomiakov	7070a16104	Add pure WireGuard direct UDP data plane plugin and transport ... Peers communicating on uncensored networks can benefit from raw WireGuard performance over direct UDP without QUIC framing or double-encryption overhead. This provides Tailscale-like direct tunnel performance while preserving Tsunagi's decentralized mesh architecture. Key changes: - Create `tsunagi-wireguard` crate implementing the `IpPlugin` and `PacketTransport` contracts: - `WG_PROTOCOL = "wg"` with wire version 1. - Bounded `WgAnnouncement` carrying WireGuard public keys, listening UDP ports, and candidate IP addresses (filtering out overlay interfaces). - `WgKeyStore` managing persistent per-network WireGuard X25519 keys in SQLite with zeroization on drop. - `WireguardTransport` providing direct UDP packet transmission, candidate address tracking, inbound link delivery, and roaming support. - `WireguardDevice` running userspace WireGuard encryption via `boringtun`, timer maintenance, and AllowedIPs source enforcement. - Integrate `wg` into `tsunagi-cli`: - Set default protocols to `"wg,tcp-tls,wg-quic"` so all protocols are enabled by default in order of throughput and performance. - Support `"wireguard"` as a convenience alias for `"wg"` in `--protocol`. - Bind `PureWgTransport` and launch the inbound datagram accept loop on `up`. - Pass `pure_wg` plugin to `AgentControl` and update `build_report` so active WireGuard tunnels and overlay metrics are reported in `tsunagi status`. - Clean up WireGuard keys on network removal in `forget_protocol_state`. - Comprehensive test coverage in `tsunagi-wireguard`: - `announcement_tests`: round-trip serialization and verification of malformed, mismatched network, zero port, or self-claiming announcements. - `transport_tests`: loopback UDP link delivery between transports. - `plugin_tests`: end-to-end two-peer handshake and bidirectional IP packet transit over direct UDP. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed.	2026-10-01 01:24:25 +01:00
Aleksandr Bogomiakov	46575d0899	Prioritize stored agreed range over default range in reserve_range ... When an agent restarted with multiple networks (e.g. hexor and ultradesu), Agent::reserve_range() previously attempted to reserve the default configured range (10.13.37.0/24) for whichever network happened to be listed first in storage, even if that network had already agreed upon a different range (such as 10.79.175.0/24). As a result, the first network seized 10.13.37.0/24 in the route table, causing the second network (which genuinely used 10.13.37.0/24) to trigger a spurious RouteError::Overlap warning at startup until the first network asynchronously loaded its signed records and released the reservation. Key changes: - In crates/tsunagi/src/agent/mod.rs, make reserve_range asynchronous and inspect stored signed records first using StateSet::agreed_range(). - If an agreed range already exists in storage, reserve that specific range in routes immediately instead of preemptively claiming the default overlay_ipv4_range. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets --jobs 2 -- --test-threads=2 passed (349 tests passed).	2026-10-01 00:36:24 +01:00
Aleksandr Bogomiakov	a89e65475d	Implement Debug manually for PipeSecurityAttributes on Windows ... The windows_sys::Win32::Security::SECURITY_ATTRIBUTES struct is a raw C FFI struct that does not implement std::fmt::Debug. Deriving Debug on PipeSecurityAttributes failed Windows compilation with E0277. Key changes: - In crates/tsunagi/src/ipc/windows.rs, remove #[derive(Debug)] on PipeSecurityAttributes and provide an explicit std::fmt::Debug implementation formatting nLength, lpSecurityDescriptor, and bInheritHandle. Validation on Linux: - Verified type check against Windows target via rustc. - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets --jobs 2 -- --test-threads=2 passed (349 tests passed).	2026-10-01 00:31:21 +01:00
Aleksandr Bogomiakov	2ed447ae86	Filter overlay interface from candidates and align status member columns ... Peers previously advertised overlay interface (tsun0) addresses as physical candidate endpoints for both iroh discovery and tcp-tls announcements. When an intermediate tunnel was active between two peers (e.g., between a host and a VM), iroh probes to the remote peer's overlay address were routed through the existing overlay, causing iroh to select the overlay IP itself as a 'direct' endpoint. This caused recursive tunneling (QUIC over WireGuard over TLS) and confusing status output showing peers connecting to their own overlay IP addresses. Additionally, in tsunagi status, peer rows were displayed with unaligned columns, mixing control plane status and data plane metrics in a way that was difficult to scan. Key improvements: - In crates/tsunagi/src/net.rs, add an AddrFilter to the iroh EndpointBuilder to dynamically filter out any local addresses assigned to tsun* overlay interfaces before publishing to address discovery services (DHT/pkarr/STUN). - In crates/tsunagi-tcp-tls/src/plugin.rs, exclude tsun* interfaces from local_ip_candidates() so overlay IPs are never advertised as physical TCP endpoints. - In crates/tsunagi-cli/src/main.rs, exclude tsun* interfaces from netwatch_addresses() so the local addresses section reflects only actual physical/host network interfaces. - In crates/tsunagi-cli/src/main.rs, update member_row() to format member details with aligned columnar layout: the overlay IP is placed first and padded, followed by control plane transport and latency, and line 2 pads tunnel metrics so that the data link endpoint (via ...) aligns vertically. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets --jobs 2 -- --test-threads=2 passed (349 tests passed).	2026-10-01 00:24:53 +01:00
Aleksandr Bogomiakov	ac5a1596ef	Allow unelevated Windows processes to access control socket via SDDL and shared path ... When running the tsunagi agent as an elevated Administrator or Windows Service, unprivileged user-space processes (such as a system tray application, user-level CLI commands, or status monitors) could not interact with the control socket. This was due to two constraints on Windows: 1. The default control socket path was derived from the per-user %APPDATA%, making an administrator's socket invisible or inaccessible to a non-elevated standard user profile. 2. Even if pointed to the same named pipe, Windows Mandatory Integrity Control (MIC) and default ACLs prevent a Medium-Integrity (unelevated) process from opening a High-Integrity (elevated) pipe server for write access unless explicitly allowed. Key changes: - In crates/tsunagi/src/ipc/windows.rs, implement PipeSecurityAttributes using Win32 ConvertStringSecurityDescriptorToSecurityDescriptorW with SDDL: "D:(A;;GRGW;;;WD)(A;;GA;;;BA)(A;;GA;;;SY)S:(ML;;NW;;;ME)". This grants generic read/write access to Everyone (WD), retains full control for Administrators (BA) and LocalSystem (SY), and sets the Mandatory Label SACL to Medium Integrity (ME) with No-Write-Up (NW). - In crates/tsunagi/src/ipc/mod.rs, introduce default_control_socket_path() which points to %ProgramData%\tsunagi\agent.sock on Windows (and default per-user state directory on Unix). - In crates/tsunagi-cli/src/main.rs, support TSUNAGI_CONTROL_SOCKET environment variable across all commands, and use default_control_socket_path() on Windows when running against the default state directory. Custom state directories (--state-dir) or explicit sockets (--control-socket) continue to take precedence, allowing multi-daemon setups to remain strictly isolated. - In workspace Cargo.toml, set unsafe_code = "deny" so the workspace forbids unsafe code while permitting explicit, documented unsafe Win32 API calls in windows.rs. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets --jobs 2 -- --test-threads=2 passed (349 tests passed).	2026-10-01 00:13:44 +01:00
Aleksandr Bogomiakov	192ab25bbd	Support RUST_LOG, enable UPnP portmapper and add NAT traversal logging ... Previously, `tsunagi-cli` configured clap with a fixed default_value and `env = "TSUNAGI_LOG"`, which caused `RUST_LOG` to be completely ignored. In addition, `iroh` was built with `default-features = false` and lacked the `"portmapper"` feature, which caused it to compile a stub client and disable UPnP-IGD, PCP, and NAT-PMP port mapping. Furthermore, there was no visibility into STUN address discovery, UPnP port mapping status, or QUIC transmission path switching (hole punch vs relay). Key improvements: - Enable the `"portmapper"` feature on `iroh` in workspace Cargo.toml, pulling in `portmapper` and `igd-next` to actively request port mappings on local routers. - In `crates/tsunagi-cli/src/main.rs`, support `RUST_LOG` with fallback precedence (`--log` > `TSUNAGI_LOG` > `RUST_LOG` > default filter). When debug or trace filtering is active, automatically enable `.with_target(true)` so users can see which subsystem emitted the log (e.g., portmapper, iroh::magicsock, tsunagi::net). - In `crates/tsunagi/src/net.rs`, monitor `endpoint.watch_addr()` and `endpoint.home_relay_status()`. Emit `DEBUG` logs for local socket binding, discovered STUN reflexive/UPnP addresses, and relay connections. If no direct addresses are discovered after probe grace, emit a concise `WARN`. - In `crates/tsunagi/src/agent/session.rs`, monitor connection `path_events()` to log when transmission paths are opened, closed, or selected (switching between relay and direct hole-punched paths), with bounded task winding down on shutdown. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (349 tests passed). - Live verification with `RUST_LOG=debug` confirmed SSDP broadcast to 239.255.255.250:1900, portmapper logs, STUN QAD discovery, and clean relay shutdown.	2026-09-30 23:08:23 +01:00
Aleksandr Bogomiakov	c0a76f1942	Enable all available protocols by default with tcp-tls priority ... By default, the agent now enables all available data plane protocols starting with `tcp-tls,wg-quic`, removing the need to manually pass `--protocol` to enable HTTPS-camouflage transport. The `--protocol` option remains available to explicitly restrict or select specific protocols (or reorder their priority). Furthermore, in `crates/tsunagi-tcp-tls`, if default port 443 is unavailable (e.g., due to permission constraints or address in use), the transport now attempts fallback port 8443, and if 8443 is also unavailable, gracefully falls back to an ephemeral port rather than failing agent startup. Key changes: - In `crates/tsunagi-cli/src/main.rs`, update `UpArgs::protocols` default_value to `"tcp-tls,wg-quic"`. - In `crates/tsunagi-cli/src/main.rs`, reorder `PROTOCOLS` registry with `tcp-tls` first, followed by `wg-quic`. - In `crates/tsunagi-tcp-tls/src/transport.rs`, add multi-tier fallback (443 -> 8443 -> ephemeral) for unconstrained port bindings. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (349 tests passed). - cargo build --release passed.	2026-09-30 22:56:08 +01:00
Aleksandr Bogomiakov	510116afb9	Add automatic protocol fallback with backoff and silence DHT bootstrap error ... When multiple data plane protocols (such as tcp-tls and wg-quic) are configured, the agent previously attempted only the first mutually supported protocol in served order. If that protocol failed to connect or dropped (due to NAT, firewall, or handshake failure), ensure_links retried the exact same failed protocol on every tick without ever falling back to alternative supported protocols. Additionally, tcp-tls mistakenly included 127.0.0.1 in peer candidate lists, causing peers to connect to their own local listener and fail certificate verification (NotValidForName). Finally, BitTorrent DHT bootstrap failures in the third-party mainline crate were logged as noisy ERRORs despite overlay connectivity operating normally. Key improvements: - In crates/tsunagi/src/agent/network.rs, implement ProtocolDialState with exponential backoff (3s, 6s, 12s, 24s, 48s, capped at 60s). - In ensure_links, select the highest-priority mutually supported protocol that is not currently on backoff cooldown. If a protocol fails, immediately record the failure and fall back to alternative mutually supported protocols without waiting for the periodic ticker. - In crates/tsunagi-tcp-tls, remove localhost loopback from local_ip_candidates and capability announcements, and prevent open() from connecting to our own listening port. - In crates/tsunagi-cli/src/main.rs, set mainline=off in the default tracing filter so benign BitTorrent DHT routing table bootstrap errors do not alarm users. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (349 tests passed). - cargo build --release passed.	2026-09-30 22:51:08 +01:00
Aleksandr Bogomiakov	e24548b3b0	Fix Windows address allocation check and add custom SNI for tcp-tls ... When running on Windows with Wintun, assigning an overlay IPv4 address via netsh triggers Duplicate Address Detection (DAD). During this tentative window, binding a UDP socket to the address returns WSAEADDRNOTAVAIL (os error 10049), causing the agent to prematurely log a false-positive PluginError ('allocated ... but the address is not on any interface'). Furthermore, Russian TSPU / DPI filters block unrecognized SNIs and non-standard ALPNs on TCP port 443 with TCP RST injection (os error 10054). The default 'tsunagi.local' SNI and 'tsunagi-tls/1' ALPN were trivially fingerprinted. Key improvements: - In crates/tsunagi/src/overlay/tun.rs, enhance address_is_local on Windows to inspect active OS interfaces via netdev::get_interfaces() if UDP bind fails. - In crates/tsunagi/src/agent/network.rs, introduce an asynchronous retry loop in publish_allocations on Windows (up to 1.5s in 150ms intervals) to gracefully allow DAD and IP helper updates to complete before reporting missing addresses. - In crates/tsunagi-tcp-tls, add support for custom SNI domain via protocol options (-o sni=<domain>), defaulting to 'cloudflare.com' instead of 'tsunagi.local'. - Switch TLS ALPN in tsunagi-tcp-tls from 'tsunagi-tls/1' to 'http/1.1' to camouflage handshake traffic as standard HTTPS web traffic. - Update tests to verify custom and default SNI behavior. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (348 tests passed). - cargo build --release passed.	2026-09-30 20:38:16 +01:00
Aleksandr Bogomiakov	a4e341cd66	Report peer tunnel protocols accurately and eliminate overlay shutdown timeout ... The status output previously reported all overlay peers under WireGuard diagnostics: when a non-WireGuard protocol (like tcp-tls) was actively carrying traffic, the report still complained that there was 'no WireGuard handshake yet; the tunnel cannot carry traffic' and marked peer health as degraded (warn). Furthermore, during agent shutdown or interface removal, the overlay packet loop waited on device.recv() for the full 5-second TASK_GRACE period, producing a spurious warning: 'task did not wind down in time; aborting it task="overlay packet loop"'. Key improvements: - Add 'protocol' field to OverlayPeerReport in tsunagi::ipc. - Track per-peer packet metrics (tx, rx, dropped) and uptime in GenericTunnelPlugin via TunnelPeerReport. - Update build_report to accurately inspect and populate active tunnel protocols (tcp-tls, wg-quic) and their real traffic counters. - Format member rows in CLI status with the actual protocol name, uptime, and real traffic metrics; mark health as Good when an active tunnel exists. - In Interface::remove(), abort the overlay packet loop task immediately before destroying the device to remove the 5s hang and spurious timeout warning. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (348 tests passed). - cargo build --release passed.	2026-09-30 17:31:17 +01:00
Aleksandr Bogomiakov	41990c9934	Refactor agent logging and report active tcp-tls tunnels ... Previous agent logging suffered from noisy repetitive '--- status ---' dumps to stdout every 15 seconds, intermingled with raw println! event lines and lacking structured log levels. Furthermore, the status report only inspected WireguardPlugin tunnels; when tcp-tls took precedence and established a link, the status falsely showed wg-quic as '0/1 tunnels established, waiting for a data link' without mentioning the active tcp-tls link. Key changes: - Adopt compact, clean tracing output: initialize tracing_subscriber with .with_target(false).compact() and default filter 'info,iroh=warn,quinn=warn,rustls=warn,boringtun=warn,mainline=warn' to keep standard agent events at INFO while silencing noisy internals. - Route agent events through structured tracing (log_event): emit INFO for peer connect/disconnect, data link up/down, and network activation; WARN for rejections and plugin errors; DEBUG for dials. - Disable periodic status dump by default (set status_interval default to 0), and re-route periodic ticks to tracing::debug! (log_status_summary). - Add active_peers() to GenericTunnelPlugin and update build_report to include active tcp-tls tunnels in OverlayReport alongside WireGuard peers. - Display enabled protocol priority on agent startup. Validation on Linux: - cargo fmt --all -- --check passed. - cargo clippy --locked --workspace --all-targets -- -D warnings passed. - cargo test --locked --workspace --all-targets passed (347 tests passed).	2026-09-30 17:16:02 +01:00
Aleksandr Bogomiakov	254a25ebd6	Display supported protocols in status report host section ... The `host` section in `tsunagi status` previously hardcoded `implementation: userspace WireGuard (boringtun); no kernel module needed` and omitted information about data plane protocols supported by the build. Changes: - Add `protocols` row to `host_section` listing supported protocols and their wire versions (`wg-quic (wire v4), tcp-tls (wire v1)`) with a note directing to `tsunagi protocols` for detailed options. - Update `implementation` row to reflect the multi-protocol userspace data plane (`userspace overlay (boringtun WireGuard, TCP TLS 1.3); no kernel module needed`). Validation on Linux: - `cargo fmt --all -- --check` passed. - `cargo clippy --locked --workspace --all-targets -- -D warnings` passed. - `cargo test --locked --workspace --all-targets` passed.	2026-09-30 17:00:39 +01:00
Aleksandr Bogomiakov	5495cb5b34	Support CAP_NET_BIND_SERVICE raising for privileged TCP TLS ports ... When file capabilities are granted with `sudo setcap ...+p`, capabilities are placed into the thread's permitted set rather than its effective set. While TUN interface provisioning in `tsunagi` properly acquired and dropped CAP_NET_ADMIN using `caps::raise`, `tsunagi-tcp-tls` attempted to bind port 443 directly without activating CAP_NET_BIND_SERVICE, resulting in EACCES (os error 13 Permission denied). Fixes and improvements: - Add `caps` dependency to `tsunagi-tcp-tls` on Linux. - Implement `NetBindServiceGuard` to temporarily raise CAP_NET_BIND_SERVICE into the effective set for the synchronous `TcpListener::bind` invocation and immediately drop it afterwards. - Clarify diagnostic warnings to distinguish between default port 443 fallback and explicitly requested port failure. - Update all privilege diagnostics and error hints across the codebase to uniformly recommend granting both capabilities: `sudo setcap cap_net_admin,cap_net_bind_service+p <path>`. Validation on Linux: - `cargo fmt --all -- --check` passed. - `cargo clippy --locked --workspace --all-targets -- -D warnings` passed. - `cargo test --locked --workspace --all-targets` passed (all workspace unit, integration, and protocol tests passed).	2026-09-30 16:53:33 +01:00
Aleksandr Bogomiakov	fac3bd7bb9	Add tcp-tls transport and tunnel protocol disguised as HTTPS ... Implement the `tcp-tls` protocol crate and generic tunnel codec abstractions alongside `wg-quic` to circumvent deep packet inspection (DPI/TSPU), UDP blocking, and QUIC throttling. Traffic uses standard TCP on port 443 with TLS 1.3 framing, looking identical to regular HTTPS traffic to network observers. Architectural highlights: - TunnelCodec & GenericTunnelPlugin: Provide an extensible plugin abstraction in `crates/tsunagi/src/dataplane/tunnel.rs` that encapsulates background task lifecycles, per-peer channels, and sink dispatch, so new transport plugins only define cryptographic transformations and handshake payloads. - MultiPacketTransport & Protocol Priority Selection: Support multiple simultaneous transports in `AgentConfig` and dynamically dispatch `open()` calls by protocol identifier. In `ensure_links`, choose the highest-priority mutually supported protocol per peer to avoid duplicate links. - TLS 1.3 & Certificate Pinning: Generate self-signed Ed25519 X.509 certificates derived from the persistent `DeviceIdentity` secret. Clients pin peer certificates using `PinnedEndpointVerifier` against `iroh::EndpointId`. - End-to-end Encryption: `PeerCipher` uses X25519 static-static ECDH, HKDF-SHA256, and ChaCha20-Poly1305 with incrementing 64-bit nonces. Relayed traffic across intermediate nodes remains confidential and tamper-proof. - Privilege handling: Default to TCP port 443 with fallback to 8443 on `PermissionDenied`, providing an actionable message recommending: `sudo setcap cap_net_admin,cap_net_bind_service+p <path>`. Validation on Linux: - `cargo fmt --all -- --check` passed. - `cargo clippy --locked --workspace --all-targets -- -D warnings` passed. - `cargo test --locked --workspace --all-targets` passed (all workspace unit, integration, CLI, and new `tsunagi-tcp-tls` tests passed).	2026-09-30 16:41:51 +01:00
ab	db9015b26c	Allow network commands to select stored names ... Leaving a configured network required copying its opaque id even when its name identified exactly one saved network. Resolve exact, case-sensitive names from the existing local state alongside full ids and unique id prefixes. Use the shared resolver for leave, stop, start, secret and broadcast so the same selector has the same meaning throughout the CLI. IPC and storage still operate on the resolved id; release and offline-removal behavior are unchanged. Refuse ambiguous names and name/id-prefix collisions before any mutation, listing matching names and full ids without secrets. Full ids take precedence to provide a definitive escape from ambiguity. Preserve copied id ellipses without stripping literal ellipses from network names. Update help and examples. Make administrator-friendly, predictable CLI behavior a core requirement in AGENTS.md, including actionable errors and no guessing which resource a destructive command should affect. Validation on Windows: cargo fmt --all -- --check and workspace/all-target Clippy with -D warnings passed. Release workspace/all-target tests: 318 passed, including real-process online/offline leave-by-name, preservation of other networks, ambiguous/unknown selectors, and consistent name selection across commands. Two existing Windows SQLite wipe failures were explicitly skipped (a_wipe_removes_everything_and_the_next_start_is_a_stranger and wiping_twice_is_as_ordinary_as_wiping_once). The public-DHT smoke test and forwarding benchmark remain ignored by default. Tests use isolated state; the user's running agent and configured networks were not changed.	2026-09-22 19:00:08 +03:00
ab	c724981bfd	Added per-network LAN broadcast relay ... LAN game discovery previously dropped IPv4 broadcasts at TUN ingress. Carry limited and subnet-directed UDP broadcasts to authenticated, opted-in members of the source network, including destinations reached through mesh relays. Preserve the original IP/UDP bytes and deliver received broadcasts only to the local TUN; never reflood them or expose another pair's plaintext at transit. Build immutable recipient snapshots on address and participation changes. The origin sends one ordinary end-to-end encrypted copy per recipient; the existing fast, bounded-hop transport router remains unchanged. Validate UDP framing, source ownership and destination admission without game-specific port rules. Keep network domains isolated and refuse implicit gateways to physical LANs. The separate broadcast policy/domain layer is the extension point for future authorized subnet exports; physical capture, bridging and LAN deduplication are deliberately not implemented yet. Persist default-on participation independently for each local network. Add join --no-broadcast/--broadcast and network broadcast <id> [on|off], including live updates and authenticated announcements. Joining without a flag preserves the saved choice. Opt-out stops local origination and delivery, while opaque unicast transit for other members keeps working. Migrate SQLite schema 3 to 4 without replacing identities or signed state. Use control ALPN 3 and local IPC protocol 14 for the new announcement/request shapes; update peers and restart running agents together. The data ALPN 4 envelope remains unchanged. No release version bump, tag or push is included. Document agent-owned commits in AGENTS.md: short English subjects, explanatory bodies, scoped staging, honest validation, and repository-local fallback author AB <ab@hexor.cy> only when an effective name/email is missing. Release actions remain the user's responsibility. Validation on Windows: cargo fmt --all -- --check; cargo check --locked --workspace --all-targets; cargo clippy --locked --workspace --all-targets -- -D warnings; release workspace/all-target tests: 313 passed. The two existing SQLite wipe failures (a_wipe_removes_everything_and_the_next_start_is_a_stranger and wiping_twice_is_as_ordinary_as_wiping_once) were explicitly skipped; the public-DHT smoke test and forwarding benchmark remain ignored by default. New coverage exercises real iroh/WireGuard multihop fanout, single delivery, runtime opt-out, unicast replies, domain isolation, malformed input and schema migration. TUNs are in-memory; actual games and OS adapter selection were not tested.	2026-09-22 18:33:52 +03:00
ab	b4f3e57c8d	Implement fast userspace multihop mesh routing ... Replace the one-intermediate-peer relay with protocol-scoped connectivity graphs and precomputed shortest-path/ECMP forwarding snapshots. Independent transport readers forward opaque transit frames without a plugin or TUN round trip. Carry source, destination, a bounded hop limit and stable flow tags; preserve end-to-end WireGuard links across topology changes. Classify IP flows before encryption and preserve their tags through the WireGuard pending queue. Add offline four-agent path-change coverage, loop and isolation tests, and an opt-in release forwarding microbenchmark. Bump control/data ALPNs while preserving persistent network identities and state. Also include the pending Windows Mainline idle-timeout fix and its regression test, using a reproducible vendored dependency patch. Validation: fmt, workspace Clippy with warnings denied, and 307 release tests passed. Two pre-existing Windows SQLite wipe failures were excluded; public DHT and the manual benchmark remain ignored by default. The forwarding microbenchmark measured 103 ns (64 B) and 202 ns (1280 B) per transit packet, excluding encryption and socket I/O.	2026-09-22 18:08:26 +03:00
ab	d1a0eca723	Fixec join CLI	2026-09-22 16:32:39 +03:00
ab	686c74a3bd	Enabled DNS by default	2026-09-22 16:08:06 +03:00
ab	9698f21d55	Added DHT peer resolver, fixed MTU	2026-09-22 15:44:33 +03:00
ab	72eaf9a228	Fixed win dns	2026-09-22 13:32:37 +03:00
ab	e735151d62	Added windown support	2026-09-22 12:34:19 +03:00
tsunagiandClaude Opus 5	458051f47d	Warn about a zone name only when it collides with something ... "`.pidar` is not a delegated top-level domain today, but it could become one" fired on every private name anybody has ever picked, which is every network without a dot in its name. A warning that is always there is a warning about nothing, and it teaches people to skim past the ones that mean something — there were two of them in one report, side by side with the real checks. What is left is the collision that exists: a name that really is a public top-level domain, which does make every public name under it unreachable from that host, and `.local`, which belongs to multicast DNS. A name that shadows nothing is said nothing about. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 02:09:17 +01:00
tsunagiandClaude Opus 5	83d3445b7e	Meet everybody, not just the one you were told about ... A device pointed at one member talked to that member and nobody else. The only candidates an agent had were the ones on its command line and whatever the cache remembered, so the network was a star around whichever peer happened to be typed — while the signed state sitting in front of it listed every other member by name. Two sources fix that, and both produce candidates rather than facts. Every author of a signed record is somebody to try. Those records reach us through anybody, so a member is known to exist, and by id, long before it is ever spoken to; an id with no address is still dialable where the endpoint's own discovery can resolve one. And members tell each other where they have seen the others. A `ControlMessage::Peers` carries each member with the addresses the sender observes for it — including the sender's own, which is the one thing nobody else can pass on — in the same `ip:`/`relay:` spelling the cache already uses, so one decoder serves both and neither can drift. An agent that only ever accepts has no candidates of its own and is exactly the one everybody was pointed at, so the addresses come from the live sessions as well as the candidate list. None of it authenticates anything. An introduction is not a vouching: the handshake decides membership as before, and a candidate from a member is tried exactly like one from a bootstrap entry or the cache. It is also deliberately the shape a distributed hash table lookup would return, so that becomes another source beside these rather than a redesign. With the mesh pairwise, the relay is what it was meant to be: the way to the one peer that cannot be reached directly, not the way the network is held together. Covered by three agents where two are told only about the first: each ends up with both of the others, and the one nobody mentioned arrives as an introduction. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 01:59:50 +01:00
tsunagiandClaude Opus 5	3581feb9b9	Reach a peer through one that can reach both ... Two members of a mesh could both reach a third and not each other, and that pair was simply lost to one another: a packet for a peer with no data link was counted undeliverable and dropped. Now it goes through a member that has both. What travels is not routes. Each agent says only which peers *it* has a live link with — first-hand, over the control plane, one hop, never a claim about somebody else's reachability — and everybody computes their own way through from that. The choice is local and deterministic (the lowest endpoint id among the peers that have a link to the destination), so there is nothing to agree, nothing to elect, and two agents may well route each direction differently. It is soft state: repeated while it holds, expired when it stops, so a relay that disappears stops being chosen without anybody revoking anything. The one in the middle carries bytes it cannot read. A datagram is wrapped with the peer it is for, and unwrapped on the other side into the link for the peer it came *from* — which matters, because a packet attributed to the carrier would be dropped as coming from an address the carrier does not hold. The tunnel stays end to end, and the relayed datagram goes link in, link out: it never reaches the middle's interface, so no routing, forwarding or firewall setting of that host is involved. One hop, so a loop cannot form without counting anything. A protocol is handed one link per peer that now outlives the paths under it. A direct link that dies, a hop that changes, a direct link that comes back: none of it tears down a tunnel any more, and the size a protocol may use does not change with the path. Where there was never a direct link at all, the link exists anyway as long as a hop does, so a peer reachable only through somebody still gets a tunnel. The data ALPN is `tsunagi/data/2`: every datagram now carries a tag saying whether it is direct, for somebody else, or from somebody else. The local control protocol is 13, for the relay counters — what this device carried for others is their traffic on its uplink, and that should not be invisible. `status` says `via <peer>` on a path through somebody. Fairness between the peers a relay carries for is deliberately not here yet: the queues are bounded and the counters are what a limit would be built on. Tested with fake links for the mechanics, and end to end with three real agents — two that cannot reach each other directly, a real WireGuard packet crossing through the middle. The one arrangement a single host cannot produce by itself is a pair that cannot see each other, so that is a `testing`-only switch on the agent config and exists in no release build. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 01:32:43 +01:00
tsunagiandClaude Opus 5	3044e592bd	Say when there is nobody to contact ... Two freshly wiped devices joined the same network, each got an address, and nothing happened. The report said "none known yet; nobody else has joined", which reads as patience — as if somebody were expected and had not arrived. What had actually happened is that neither agent had anywhere to look: this project publishes nothing about who is in which network, so a first meeting needs one of them to be told the other's endpoint id, and the hints an agent remembers from earlier sessions had gone with the wipe. Candidates are now in the report, and having none of them with nobody connected is said plainly, with both ways out of it and this device's own id ready to hand to the other side. Having some and no sessions yet is the ordinary state of a network coming up, and stays ungraded. The local control protocol is 12. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 00:51:39 +01:00
tsunagiandClaude Opus 5	9b240672e6	Put every network's address on the interface, and split up from join ... Two networks on one agent, and only one of them worked. The interface plan is exhaustive by contract — it is what the interface should carry and nothing else — but the request that built it held a single address, so the provisioner was told about the first network and took the second one's address off, or never put it on. On the host that is a network whose address the operating system has never heard of: the tunnel is up, the status says all is well, and nothing routes. The request now carries every address, which is also what takes one off when a network is left or stopped. The other half is the command line. `up --network X --secret Y` and `network join` were two ways to do the same thing, and the one on `up` could only be undone by restarting — which is how a network somebody left came back, and how an invite line told the other side to start their agent with a network baked into it. So they are one thing now, split the way the system is: **`up` runs the agent** — the device's one process, serving whatever it has joined, answering `status`, taking instructions — and **`join` decides what it belongs to**, at any time, while it runs. `join` is at the top level because it is what gets typed; `network join` is the same command for anyone who likes the long form. Every line that told somebody to type the old form is gone with it: the invite after making a network, the lock error from a second `up`, the empty-network hint in `id`, the README walkthrough and the WireGuard document. The invite now prints the `join` line for the other machine and, separately, the `up --peer` line for an agent that is not running yet — two commands, because they really are two, and no amount of wording makes starting an agent the same thing as joining a network. Joining says how the network stood before: new, already here, or stopped and now running again. That last one matters — joining is an instruction to run it, so it undoes a stop, and a pause that ends without a word is a pause nobody can rely on. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 00:30:03 +01:00
tsunagiandClaude Opus 5	1b2f050c05	Start the agent without deciding anything yet ... `up` demanded a network, so there was no way to run the agent in one terminal and decide what it belongs to in another — which is the shape of the thing now that networks are joined, stopped and left while it runs. `--network` is optional. Without it the agent starts with whatever it is already configured for and waits; the banner counts the networks instead of naming one, and points at `tsunagi network join`. A secret with no network is refused rather than ignored, because it says nothing on its own. The periodic summary, which had one network by construction, now falls back to the first running one — `tsunagi status` is the whole picture and this line was never more than a glance. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-21 23:36:36 +01:00
tsunagiandClaude Opus 5	637e2f74e4	Tell being away from giving up ... Leaving was the only way out of a network, and it is the irreversible one: it publishes a release and then removes the configuration, the secret, the network's signed records, its cached hints and the protocol key it used. What somebody usually wants before a reboot, a trip or an experiment is the other thing — stop serving it and keep everything. `tsunagi network stop <id>` closes that network's sessions, takes its address off the interface and keeps it from starting again. Nothing is announced, deliberately: to the others this device is away, which is an ordinary condition they already handle, and the address and name it holds stay reserved for it. `tsunagi network start <id>` resumes it where it left off. Both are remembered, so a restart does what the last instruction said rather than what the last command line happened to say. Except when the command line says otherwise: `up --network X` starts X whatever its stored state, because a command naming a network is an instruction to run it. The banner now says which of the three happened — `new`, `already here`, or `was stopped; this command starts it` — since silently, that is a stop that comes back from the dead with nothing to explain it. The listing tells the three states apart too: running with its address, stopped and kept, or configured and waiting for an agent to start. Each row says what to type to move it, because "stop" and "leave" are a pair that has to be easy to tell apart before the irreversible one is typed. The local control protocol is 11. Covered end to end against a running agent: stopping leaves it configured and says so, stopping twice is the state asked for rather than an error, starting brings it back, and the secret afterwards is the one from before — so it is the same network and not a lookalike. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-21 23:32:23 +01:00
tsunagiandClaude Opus 5	415b6a6667	Make a network on the spot, and say which one you just started ... Two reports of the same shape: a network was left and came back after a restart, and `network join` asked for a secret it could have invented. The first was not a bug in leaving. The secret on the start command line derives the network id, so a command line carrying the secret of a network you have just left recreates it on the next start — which is right, it says to join that network, but nothing on screen said so. `up` now marks the network `· new` or `· already here`, and warns in full when another configured network answers to the same name. A name is a label; the id is the identity, and the secret is what decides which of them this is. Said at the moment it happens it is obvious; discovered later in a status report it is a mystery, which is exactly how it went. The second was an omission: `up` had learned to invent a secret and `network join` had not, so the quickest possible thing — a network with somebody for as long as it is needed, then gone — still needed a secret generated first. Both now resolve a bare name the same way: the one network of that name this device already has, or a fresh random secret when there is none. It is printed in full, with the single line the other person can paste as it stands, endpoint id included, because a secret nobody can read is a network nobody can join. The id is printed in full by both answers now. The shortened form belongs in a report, where it is read; this one gets copied into the next command. Covered end to end against a running agent: joining with no secret prints a secret and a pasteable command with a peer in it, and joining a name this device already has resumes that network instead of making another that merely looks the same. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-21 23:19:58 +01:00
tsunagiandClaude Opus 5	0f97d60854	Serve a zone per network, and make a network in one command ... Twice now a report has read "dns not serving" and been taken for a broken resolver. It was accurate both times: the agent had been started without `--dns`. That is the flag's fault, not the reader's — a resolver that disappears because one word was not retyped is worse than none, since the names simply stop working. So the setting belongs to the device now: `--dns` turns it on and it stays on, `tsunagi dns off` turns it off, and `tsunagi dns on` turns it on for an agent that is already running, without restarting it. `tsunagi dns` says what it is doing, or what it will do at the next start when nothing is running. One agent has one identity and as many networks as it likes, so one DNS service serves them all: each network is a zone named after it, and joining or leaving one changes what resolves with no restart. A question carries a name and not the network it belongs to, so the suffix decides and nothing is shared between zones — a member of one network is not a name in another. `--dns-zone` is gone with that: there is no single zone to name any more, and a network name may contain dots, so `--network lab.internal` is how you get `music.lab.internal`. It listens on loopback only, where it always could have. Binding the overlay address put the zones in front of the whole mesh, and with several networks on one agent that would have answered one network's questions about another's names. That made a gap plain: a second network on an agent had no addresses at all, because the configured range belongs to whichever network took it first, so its members had nothing to allocate from and no names to answer with. A second network now uses the range **derived from its own network id** — every member derives the same one from something they all already have, so it is an agreement rather than a local invention. It is held back for a moment first, because a network that already exists has a range of its own and a joiner should adopt it rather than argue; that wait is what keeps "the first member settles it" true. And a network needs no ceremony to start. `tsunagi up --network lab` with no secret resolves the obvious way: the one network of that name this device already has, or — when there is none — a fresh random secret, printed in full with the single line to send the others. That is the ad-hoc case, one person makes a network and passes the command round, and it was previously two steps with a flag people could not find. The secret is printed only when the agent invented it, because then there is nowhere else to read it from; one that was supplied is not echoed. Two networks of one name and no secret is the one case with no answer, and it says so rather than choosing. Releasing now also stops this agent claiming again. The periodic check would otherwise publish a fresh claim in the moment between the goodbye and the teardown, turning a release into a hello nobody asked for. Exercised with the real binary: a zone per network as a second one is joined into a running agent, the resolver switched on and off while it runs, and an ad-hoc network printing its secret and the line to share. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-21 23:03:42 +01:00