xinyin025/3x-ui
1
0
Fork 0
mirror of https://github.com/MHSanaei/3x-ui.git synced 2026-08-24 20:07:13 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
940842495968fc52a38fd0a8f6f8498dd6e70de5
3x-ui/internal/web/translation/pt-BR.json
T
Kuzz007 effcccceac feat(amneziawg): add native AmneziaWG protocol support (#6105) 
* feat(amneziawg): add native AmneziaWG protocol backend

AmneziaWG (WireGuard plus DPI-resistant obfuscation) needs no Docker
here — it runs as a genuine kernel interface via awg-quick/awg, managed
the same way internal/mtproto manages mtg: one Inbound row is one
desired Instance, and a Manager reconciles running interfaces toward
the database every 10s (internal/web/job/amneziawg_job.go) plus
immediately after a client edit (applyLocalAmneziaWG).

Clients reuse model.Client verbatim (the same PrivateKey/PublicKey/
PreSharedKey/AllowedIPs fields WireGuard already uses), so bulk
operations, the QR/share-link modal and subscriptions come from the
shared inbound infrastructure instead of a parallel implementation.
internal/amneziawg owns the obfuscation param generator/validator
(ported from coinman-dev/3ax-ui, upgraded to AmneziaWG 2.0's S3/S4
padding and I1 signature packet) and the exec wrapper around
awg-quick/awg, with fingerprint-based reconcile (noop / reload-via-
syncconf / full restart) mirroring mtproto.Manager so a same-protocol
edit doesn't force an unnecessary interface bounce that would drop
every peer's connection.

Frontend and install.sh's DKMS/awg-tools setup are tracked separately;
this is backend-only.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): add frontend support and fix a Go->Zod generator gap

Wires the amneziawg protocol through the panel UI the same way every
other protocol is registered: a Zod settings schema (nested
{server, clients}, matching the Go JSON exactly), the protocol enum,
the inbound-form's per-protocol fields component and its
tab-visibility allowlist, the default-settings factory, the client
schema dispatcher, and the sniffing-capability exclusion (no Xray
inbound exists for amneziawg, same as mtproto).

Client key/allowedIPs fields are reused rather than duplicated: since
AmneziaWG clients are wire-identical to WireGuard clients (same
model.Client fields), ClientFormModal renders one shared field block
for both, switching only the visible label by which protocol is
active. The private-key input also gets a live public-key sync via a
new useEffect, because unlike WireGuard's Xray-native inbound (which
re-derives its public key at runtime and never stores one),
AmneziaWG's server.publicKey is a real persisted field the Go backend
reads directly — free-typing a new private key without this would
silently save a mismatched keypair.

Adds a downloadable per-client .conf (amneziawgConfig.ts, mirroring
wireguardConfig.ts) with the obfuscation lines, and an
InboundOption.AwgServer field on the Go side so the config builder
gets the full server block in one round trip.

Along the way, running tools/openapigen surfaced a real bug: it
doesn't flatten anonymously-embedded Go structs the way encoding/json
does, so ServerSettings embedding Obfuscation20 produced a Zod schema
with a nested `obfuscation20` key that never matches the real wire
JSON. Fixed by un-embedding (flat fields + an accessor method) and
registering internal/amneziawg in the generator's own package list,
which had been silently emitting a dangling schema reference.

English and Russian translations are complete; the other 10 locale
files still fall back to English for the new keys.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): complete frontend parity for the Inbounds list page

The Clients page (form, CRUD, QR/config) already worked from the
prior commit; this closes the remaining gap on the Inbounds side and
in a couple of protocol allowlists that a plain search for existing
wireguard/mtproto handling turned up.

lib/xray/inbound-link.ts gets amneziawg-specific link/config builders
(genAmneziaWGLink/genAmneziaWGConfig, plus the *s fan-out variants)
mirroring the wireguard ones — AmneziaWG has no legacy peers-array to
fall back to, so these read settings.clients directly and add the
obfuscation lines every client must share with the server. Wired into
genInboundLinks generically, and into three consumers that call the
wireguard builders directly rather than through that dispatcher:
QrCodeModal, InboundInfoModal, and InboundsPage's bulk export.

ClientInfoModal, ClientBulkAddModal, and the bulk attach/detach modals
each had their own protocol allowlist that needed amneziawg added
alongside wireguard/mtproto.

Two real gaps surfaced by grepping every remaining 'wireguard' /
Protocols.WIREGUARD hit in frontend/src rather than trusting the
checklist was exhaustive:
- useInbounds.ts's TRACKED_PROTOCOLS gates the deactive/depleted/
  expiring/online client counts shown per inbound on the list page;
  without amneziawg those counts would silently read zero.
- inbound-tag.ts is an explicit client-side mirror of the Go backend's
  port_conflict.go (the file says so itself: "Keep in sync"). It still
  only special-cased wireguard for UDP, so an amneziawg inbound would
  have fallen through to the TCP default and disagreed with the
  backend's own port-conflict math.

Also finishes translating the AmneziaWG UI strings into the 11 locale
files that were still falling back to English (ar-EG, es-ES, fa-IR,
id-ID, ja-JP, pt-BR, tr-TR, uk-UA, vi-VN, zh-CN, zh-TW), matching
en-US/ru-RU key-for-key (26 new keys, verified by count in every file).

Not run anywhere: npm run typecheck / build. This machine has neither
Node nor npm, so nothing here has compiled — reviewed by hand plus
brace/paren balance checks and cross-referencing the generated Zod/TS
types. Treat this as needing a real typecheck before shipping.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(install): note that AmneziaWG kernel module install is still manual

Tracked separately (not yet ported into this script) — see
coinman-dev/3ax-ui's install_amneziawg for the reference approach
(ppa:amnezia/ppa). Also serves as a real, path-filter-matching change
to get the previous empty commit's CI trigger to actually fire —
release.yml's push trigger is paths-scoped and an empty commit changes
no files, so it never matched.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): add a button to randomize obfuscation parameters

Mirrors the existing key-regenerate button next to the private key
field. Client-side randomization matches the ranges/constraints of
GenerateObfuscation20's "default" preset (internal/amneziawg/params.go)
closely enough for a form suggestion — the user can still hand-edit any
field afterward.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(install): auto-install the AmneziaWG DKMS module + amneziawg-tools

Ports install_amneziawg from coinman-dev/3ax-ui's install.sh, adapted to
this script's broader distro coverage and NONINTERACTIVE convention:

- Ubuntu/Debian/Armbian: ppa:amnezia/ppa (primary, tested path), with a
  reachability pre-check for the Launchpad PPA host — often blocked by
  hosting providers, especially Russian VPS — so a flaky network skips
  the feature instead of hanging apt through several retries.
- Fedora/RHEL-family, Arch/Manjaro/Parch: best-effort fallback to plain
  wireguard-tools (+ AUR amneziawg-dkms via yay/paru when available),
  with a manual-install pointer.
- Everything else: manual-install pointer only.

Also installs ndppd and persists IPv4/IPv6 forwarding (for the future
IPv6/NDP phase, not yet wired into the panel) and adds a Secure Boot
warning at the end of the run, since a DKMS-built module is unsigned
and won't load while it's enabled — a common trap on cloud VPS images.

Never fatal: the panel installs and runs fine either way, an AmneziaWG
inbound just won't bring up its tunnel until the module is present.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): resolve all 3 real CI failures (typecheck/lint/codegen)

Found by checking the fork's Actions tab after the last two pushes —
the release build passed (it doesn't run these checks) but the
separate CI workflow caught three real issues:

- golangci-lint (noctx): every internal/amneziawg/manager.go exec.Command
  call is now exec.CommandContext with a 30s timeout, so a hung
  awg-quick/awg invocation can't block the reconcile job indefinitely
  (mirrors internal/mtproto/process.go's own CommandContext usage).
- tsc --noEmit: frontend/src/schemas/client.ts's hand-maintained
  InboundOptionSchema (used by the useClients hook, separate from the
  auto-generated one in generated/) never got an awgServer field added
  when the AmneziaWG frontend work was done — every read of
  inbound.awgServer.* in amneziawgConfig.ts was typing as {}. Added
  AwgServerOptionSchema, nested (not flattened like wg*) to match what
  amneziawgConfig.ts already expects. Also guarded server.publicKey in
  inbound-link.ts's genAmneziaWGLink against the schema's optional type.
- codegen staleness: frontend/public/openapi.json is produced by a Node
  script (gen:api) this machine can't run; hand-applied the exact diff
  the CI failure log already showed (amneziawg protocol enum entry,
  ServerSettings schema, InboundOption.awgServer, one example payload),
  verified as valid JSON.

Also confirmed independently by this run: install_amneziawg (previous
commit) installed and loaded the DKMS module successfully on both amd64
and arm64 CI runners. The two "Deploy Smoke Tests" failures are
unrelated to this change — this fork has only ever published the
dev-latest pre-release, and GitHub's /releases/latest API deliberately
excludes pre-releases, so the smoke test's no-argument install path
(which resolves "latest") has nothing to find. Not a regression; needs
an actual tagged release whenever that's wanted.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): Phase 2a — IPv6 support + NDP proxy

Adds native dual-stack IPv6 to AmneziaWG inbounds, ported from
coinman-dev/3ax-ui's approach:

- ServerSettings gets ipv6Enabled/ipv6Subnet/ipv6ExternalInterface;
  Instance carries the server's own IPv6 address (first host of the
  subnet) alongside its IPv4 one.
- defaultAmneziaWGClients allocates an IPv6 host address per client
  (second AllowedIPs entry) when the server has IPv6 enabled, reusing
  allocateWireguardAddress — which needed a real fix along the way: it
  always suffixed "/32" regardless of address family, which is wrong
  for an IPv6 host address (needs /128). Now family-aware.
- generateServerConfig's PostUp/PostDown gains IPv6 forward-accept
  rules, proxy_ndp sysctl, and one `ip -6 neigh add/del proxy` entry per
  enabled peer with an IPv6 address — the lightweight per-client
  method, not the ndppd-daemon whole-subnet method (not worth the
  config-file-management complexity at this scale; ndppd itself is
  still installed by install.sh in case that changes later).
- ValidateIPv6Subnet rejects a malformed subnet before save.
- Frontend: ipv6Enabled/ipv6Subnet/ipv6ExternalInterface fields on the
  AmneziaWG inbound form, EN+RU translations, openapi.json/generated/*
  regenerated (the latter via `go run ./tools/openapigen`, pure Go).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): fill in IPv6 fields missed by the Phase 2a commit

Two real gaps the CI caught (both new fields, both my miss):

- inbound-defaults.ts's createDefaultAmneziawgInboundSettings() built a
  server object literal predating ipv6Enabled/ipv6Subnet/
  ipv6ExternalInterface — AmneziawgServer's inferred type now requires
  them (zod .default() fields are non-optional post-parse), so this
  didn't typecheck at all.
- openapi.json's ipv6Enabled property was missing the description the
  real generator attaches (the Go doc comment covering all three IPv6
  fields is attached to the first one) — a one-line diff, but git
  diff --exit-code doesn't care how small.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): Phase 2b — per-client port-forwarding

Admins can now set a per-client ForwardedPorts string (e.g. "80, 443,
8000-8100") that gets DNAT'd + FORWARD'd to that peer's tunnel address
via iptables rules in PostUp/PostDown, ported and simplified from
coinman-dev/3ax-ui's shared/portfwd.

Two decisions worth flagging for future readers:

- The iptables --comment tag on each rule is awg-fwd-<fnv32a(email)>,
  not the raw client email. Email is admin/API-supplied free text that
  ends up embedded in a shell-executed PostUp/PostDown line; a hash
  can never carry a shell metacharacter through where raw
  interpolation could.
- The reconcile manager gained a third fingerprint (portFwdFP, next to
  the existing structural/peers ones). `awg syncconf` only touches the
  WireGuard peer table — it never re-applies PostUp/PostDown iptables
  rules — so a port-forward-only change has to force a full
  awg-quick down+up bounce, same as a structural change, rather than
  the lighter sync a plain peer add/remove can use.

Also fixes a real pre-existing bug found while wiring up IPv6 client
allocation in the previous commit's spirit: allocateWireguardAddress
always suffixed "/32" regardless of address family, which produced
invalid host bits for IPv6 (needs "/128").

ForwardedPorts flows through model.Client -> model.ClientRecord
(gorm column wg_forwarded_ports, auto-migrated) -> ToRecord/ToClient/
MergeClientRecord, mirroring the awgServer field's earlier lesson
that new fields need checking against a second, hand-maintained
persistence-layer struct.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): route a client's traffic through Xray via the Routing page

Every enabled AmneziaWG inbound gets its own Xray TPROXY bridge
automatically, with no toggle to enable first: a loopback
dokodemo-door inbound (sockopt.tproxy) tagged with the AmneziaWG
inbound's own real tag, so it's already selectable in the existing
Routing page's inbound-tag picker — the same trick the mtproto
sidecar's own bridge already relies on (InboundService.GetInboundTags
is a plain, protocol-blind SELECT over every inbound row's tag, no
dedicated UI plumbing needed).

internal/amneziawg's defaultPostUpDown TPROXYs every peer's traffic
into that bridge unconditionally; the bridge's port is derived
deterministically from the inbound's id (EgressPortForInbound) so the
kernel-side reconcile loop and the Xray-config generator never need to
negotiate a runtime value between them.

injectAmneziawgEgress never generates a routing rule itself — whether
a client's traffic goes anywhere beyond Xray's default routing is
entirely up to whatever rules the admin adds through the existing
Routing UI (pick the AmneziaWG inbound's tag as source, optionally a
specific peer's IP via that page's own Source-IP field, and an
outbound), exactly the same workflow as routing any other protocol.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): recover orphaned interfaces after an ungraceful exit

Two gaps left an AmneziaWG interface stuck outside the manager's
control after a crash (kill -9/OOM/panic skips StopAll):

- ensureRestart's teardown was gated on the in-memory `exists` map,
  which is always empty on a fresh process, so a survived interface
  never got interfaceDown before interfaceUp tried `ip link add`
  against a name the kernel already had — failing forever and never
  populating m.ifaces, so traffic accounting silently stopped and the
  inbound could never be removed. Gate on isInterfaceUp instead, which
  checks real kernel state rather than this process's own bookkeeping.

- An inbound deleted from the database entirely while the panel was
  down has no entry in `desired` ever again, so it never reaches the
  per-id cleanup loop in Reconcile (which only walks m.ifaces). Add a
  one-time sweepOrphansLocked scan of configDir, mirroring
  mtproto.Manager.sweepOrphansLocked, that tears down and removes any
  leftover interface/config not in the current desired set.

Found by the automated review on MHSanaei/3x-ui#6105 (Finding 1).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* i18n(amneziawg): backfill IPv6/obfuscation/port-forwarding keys in 11 locales

Only en-US/ru-RU ever got these 9 keys as each AmneziaWG feature landed
(the regenerate-obfuscation button, then Phase 2a's IPv6 fields, then
Phase 2b's per-client ForwardedPorts) — the other 11 locale files were
never backfilled, so i18next has been silently falling back to English
for all of them since Phase 1. Cosmetic-only (never broke anything),
but now closed for every shipped locale.

* fix(amneziawg): resolve 7 Medium findings from the automated PR review

Each is independently reproducible; fixed together since one review pass
found all of them.

- manager.go: the shared "ip rule add fwmark" policy route had no
  existence check, so it duplicated in "ip rule show" on every interface
  bounce (which hostRulesFingerprint forces on any client add/remove/
  re-IP). Now checked via "ip rule list | grep -q ..." first. (Finding 2)

- params.go: ExternalInterface, IPv6ExternalInterface, and subnetIp/
  subnetCidr are interpolated unescaped into a shell-executed PostUp/
  PostDown line, but only obfuscation and the IPv6 subnet were validated
  before save. Added ValidateInterfaceName (a strict charset+length
  pattern) and ValidateSubnetIPv4 (netip.ParsePrefix), wired into
  normalizeAmneziaWGSettings. (Finding 3)

- amneziawg_job.go: IsAwgInstalled() existed but nothing ever called it,
  so a host without awg/awg-quick (the Docker image, RHEL, Arch, a failed
  install.sh PPA step) logged a reconcile failure every 10s forever. Now
  checked once an inbound actually needs it, warning once instead of
  spamming. (Finding 4)

- client_inbound_apply.go: the WireGuard/AmneziaWG credential
  carry-forward (added so a metadata-only client edit doesn't rotate
  keys) never covered ForwardedPorts, so a partial edit -- an API call or
  Telegram-bot toggle that omits the field -- silently wiped a client's
  port-forwarding spec. Carried forward and written back the same way the
  key fields already are. (Finding 5)

- manager.go: hostRulesFingerprint keyed each peer on its IPv4 address
  only, and structuralFingerprint omitted IPv6Enabled/IPv6ExternalInterface
  entirely, so an IPv6-only change could pick the syncconf reload path
  (which never re-runs PostUp, leaving a stale NDP-proxy entry) or be a
  complete no-op. Both fingerprints now cover the IPv6 fields. (Finding 6)

- port_conflict.go: the AmneziaWG egress bridge (injectAmneziawgEgress)
  binds 127.0.0.1:63100+id with no collision check anywhere, since it
  isn't a database row the ordinary port-conflict query can see -- same
  blind spot the reserved Xray API port already has its own check for.
  Added the equivalent check for the AmneziaWG bridge port. (Finding 7)

- install.sh: install_amneziawg ran unconditionally for every install/
  update, building a DKMS kernel module and enabling host-wide IPv4/IPv6
  forwarding whether or not the feature is ever used. Gated behind a new
  should_install_amneziawg (XUI_INSTALL_AMNEZIAWG=true/false, or an
  interactive y/N prompt defaulting to no). Also replaced the deprecated
  apt-key adv with a dedicated keyring + signed-by= on the Debian branch,
  and guarded its sources.list appends against duplication on a retried
  install. (Finding 8)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): make the Xray TPROXY bridge a per-inbound opt-in

Addresses Finding 10 from the automated PR review: an always-on TPROXY
bridge makes every AmneziaWG tunnel hard-depend on Xray being up (all
traffic, including DNS, drops whenever Xray restarts), and forces a full
awg-quick down+up bounce on any client add/remove/re-IP, permanently
losing the syncconf fast path.

Adds ServerSettings.RouteThroughXray (off by default):

- defaultPostUpDown only emits the TPROXY/policy-route rules when it's
  on; a plain AmneziaWG tunnel now has zero Xray dependency out of the
  box.
- structuralFingerprint covers it (toggling it changes whether PostUp/
  PostDown contain any TPROXY rules at all -- structural, not a
  per-peer host-rule). hostRulesFingerprint's IPv4 tracking is now
  itself conditional on RouteThroughXray (and IPv6 tracking on
  IPv6Enabled), so an instance that never uses either keeps the
  syncconf fast path for a plain peer re-IP.
- injectAmneziawgEgress only creates a bridge for inbounds that opted
  in; checkAmneziawgEgressConflict (the Finding-7 fix) now parses each
  candidate through InstanceFromInbound so a non-routed inbound's port
  is correctly never treated as reserved.
- New inbound-level Switch in the AmneziaWG form; the actual outbound
  decision is still made entirely through the panel's stock Routing
  page, same as before -- only whether the bridge exists at all is now
  a choice.

Translation keys added to all 13 locales in the same commit this time,
not backfilled later (see Finding 9's lesson).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): resolve 4 Low findings from the automated PR review

- manager.go: serverAddress assumed subnetIp always ends in ".0"; a
  base like "10.8.1.5" was used verbatim as the server's own address,
  eventually colliding with peer allocation (which starts at .2
  upward). Now derives the first host of the actual subnetIp/subnetCidr
  network via netip, matching serverAddressV6's own approach. A /32
  base (no host bits at all) is still used as-is. (Finding 12, partial
  -- the /16 pool-widening half of this finding only exists on the
  upstream-pr/amneziawg branch's merged client_wireguard.go, not here;
  handled separately on that branch.)

- manager.go: ensureLocked carried the previous per-peer traffic
  counters (`last`) forward even through a full restart, but
  awg-quick down+up resets the kernel's own counters to zero -- the
  next CollectTraffic computed a large negative delta (clamped to 0),
  silently discarding real traffic. Extracted the decision into
  nextTrafficBaseline: only a reload (syncconf) preserves the
  baseline. (Finding 13)

- portfwd.go: exported ForwardedPortsInclude; inbound_amneziawg.go's
  new checkForwardedPortsConflict uses it to reject, at save time, a
  client's forwardedPorts that would DNAT the panel's own port or
  another enabled inbound's port to the tunnel client --
  portForwardLines has no destination restriction, so this collision
  was previously silent. Wired into both the single-client update path
  and the add-client path (client_inbound_apply.go), plus
  normalizeAmneziaWGSettings for the whole-inbound save path. (Finding 14)

- inbound.go: InboundOption.AwgServer sent the whole ServerSettings
  struct including PrivateKey to GetInboundOptions callers -- a
  shared, admin-wide dropdown-filling endpoint the frontend's own
  AwgServerOptionSchema never reads that field from. Redacted it
  before assigning. (Finding 11)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): don't widen the peer address pool past AmneziaWG's own subnet

Completes Finding 12 from the automated PR review (the serverAddress half
of this finding was already fixed on main and cherry-picked here). This
half is specific to this branch: allocateWireguardAddress's /16
pool-widening fallback is an independent addition from upstream's own
main that this branch inherited during the cherry-pick rebase -- it
doesn't exist on the fork's own main at all, so this fix can't be
cherry-picked the normal way and is committed directly here.

Widening is safe for WireGuard's own Xray-native inbound (AllowedIPs
isn't tied to a strict kernel interface subnet), but AmneziaWG's kernel
interface Address is exactly the configured subnet -- an address
allocated from the containing /16 once the /24 fills up would be
silently unroutable. allocateWireguardAddress now takes an explicit
allowWidening bool: WireGuard's own caller passes true (unchanged
behavior), AmneziaWG's passes false (fails loudly on exhaustion instead).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(docker): note that AmneziaWG doesn't work in this image

Investigated: the image is Alpine-based, and AmneziaWG's own packaging
(DKMS module + amneziawg-tools) doesn't target Alpine/musl at all --
unlike the Debian/Ubuntu/Fedora/Arch paths install.sh already handles,
there's no package to apk add even with full host network/capabilities.
The panel already degrades gracefully (IsAwgInstalled() logs one warning
instead of retrying forever), so no code change is needed -- just made
the reason explicit at the point where a user would reach for cap_add/
network_mode to try to work around it.

* fix(sub): include amneziawg inbounds in subscription links

getInboundsBySubId's SQL protocol allowlist never had 'amneziawg' added,
so every AmneziaWG client was silently excluded from all three
subscription formats (plain/individual links, JSON, Clash) and from the
Telegram bot's QR/individual-link buttons, which fetch through the same
path. genAmneziaWGLink itself was already fully implemented and already
wired into GetLink's dispatch switch -- it just never got a chance to
run. Same bug shape as the earlier TRACKED_PROTOCOLS frontend gap: a
hardcoded protocol list one entry short.

Found while investigating whether the Telegram bot needed AmneziaWG-
specific client-management code -- it doesn't (the bot itself is fully
protocol-agnostic), but this is the actual root cause of "can't share
an AmneziaWG client's config via the bot."

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(inbound): enforce node-eligibility server-side, not just in the UI

Investigated multi-node interaction with AmneziaWG: the master's own
reconcile (DesiredAmneziaWGInstances) and Xray config generation
(injectAmneziawgEgress, the GenXrayInboundConfig protocol skip) all
correctly filter on NodeID IS NULL, so a node-assigned AmneziaWG (or
MTProto) inbound would never be managed by the master. But nothing
stopped one from being created that way: NODE_ELIGIBLE_PROTOCOLS
(frontend/src/pages/inbounds/form/InboundFormModal.tsx) only hides the
node picker client-side -- a direct API call could set nodeId on an
AmneziaWG inbound, which every node then reconciles as an ordinary
local inbound (nodes run the identical binary, full cron suite
included), leaving it running unmanaged and untracked by the master's
own AmneziaWG bookkeeping.

Added isNodeEligibleProtocol (inbound_protocol.go), mirroring the
frontend's allowlist, and enforced it in both AddInbound (the actually
exploitable path -- nodeId comes straight from the request) and
UpdateInbound (defense in depth; NodeID is already restored from the
stored row there before this check, so it mainly guards against a
protocol change on an existing node-hosted inbound).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): allow TPROXY-marked traffic through a default-deny INPUT chain

TPROXY never rewrites a packet's own destination address, only the routing
decision. A default-deny firewall whose INPUT chain sanity-checks "is this
destination actually local" (UFW's ufw-not-local, via addrtype --dst-type
LOCAL, is a concrete example) silently drops the redirected packet before
Xray's socket ever sees it -- RouteThroughXray looked fully configured
(TPROXY rule present and counting, Xray listening with IP_TRANSPARENT set)
yet every peer's traffic vanished with no trace on either side.

Adds an idempotent, never-torn-down "iptables -I INPUT 1 -m mark --mark
<fwmark> -j ACCEPT" alongside the existing shared policy route, so this
works regardless of which firewall manager owns the rest of the INPUT chain.

* fix(frontend): give AmneziaWG the same UDP tag and its own tag color

The Inbounds list only special-cased isWireguard/isHysteria for the "UDP"
network badge, so an AmneziaWG row showed just the bare protocol tag with
no transport badge next to it. Added the missing isAmneziawg flag (mirrors
isWireguard exactly) and wired it into the same branch.

Client-row protocol-color maps in ClientsPage/HostList had no amneziawg
entry, silently falling back to grey -- ClientInfoModal already had
amneziawg: 'yellow' from earlier work, these two just never got it.

* feat(logs): show which AmneziaWG client an access-log line belongs to

The dokodemo-door TPROXY bridge every AmneziaWG peer's traffic is routed
through has no per-user identity, so Xray's own access log never carries an
"email:" token for these lines -- the Access Logs modal showed a blank
Email column for every in-*-udp row, even though every other protocol's
rows show the client normally.

The peer's decapsulated tunnel IP does survive as the log's "from" address,
and that IP deterministically maps to exactly one configured peer. Builds a
"<inbound tag>|<ip>" -> email index from the same AmneziaWG inbounds already
parsed elsewhere (amneziawg.InstanceFromInbound), and fills in Email from it
whenever the raw log line didn't have one.

* fix(amneziawg): enable sniffing on the TPROXY bridge

Domain-based Routing rules could never match RouteThroughXray traffic: an
AmneziaWG peer resolves DNS itself, through the tunnel, before ever sending
a packet, so the decapsulated traffic TPROXY hands to the bridge is already
a bare destination IP with no domain name attached at the network layer.
Every other inbound recovers this via sniffing (confirmed working for the
stock wireguard inbound, which does have it configured); the bridge never
got a sniffing block at all, so only tag/IP/network-based rules could ever
match it -- any domain rule above it in the list was silently unreachable.

* docs: add an AmneziaWG config page and list it as a supported protocol

Closes the PR checklist gap: the feature shipped with zero mention on
the docs site. Mirrors reality.mdx's structure (key settings, setup
steps, config excerpt) and notes the Docker/multi-node/Telegram-bot
caveats the PR itself is honest about not having confirmed.

* fix: address the fresh review round on PR #6105 (8 findings)

1. hostRulesFingerprint didn't account for ForwardedPorts when
   RouteThroughXray was off, so re-IPing a peer with port-forwarding
   configured left stale DNAT rules pointing at an address the next
   peer could be handed.
2. Server/client config values (keys, email, I1) were never validated
   for control characters before being written into the generated
   .conf; a newline could smuggle a PostUp hook into awg-quick's
   parser. Added ValidateConfigValue at save time and a
   sanitizeConfigValue backstop at render time.
3. checkForwardedPortsConflict didn't scope to node_id IS NULL, so a
   port used only on a different node produced a false collision; also
   hoisted the panel-port/inbounds lookup out of the per-client loop
   (portConflictContext) so N clients cost one query, not N.
4. PostDown commands were ";"-joined and abort on the first failure;
   appendOrTrue makes teardown best-effort so an external firewall
   flush can't leave DNAT rules to accumulate across bounces.
5. The "ip rule list | grep -q" existence check could SIGPIPE under
   pipefail and re-add a duplicate rule; switched to grep -c >/dev/null.
6. Ported the vpn:// share-link format (base64url of the plain .conf
   text, matching the real AmneziaVPN app) onto this branch -- it had
   only ever landed on our own fork's main, so this PR branch was still
   on the old amneziawg://+query-params scheme our own docs no longer
   described. Also corrected the docs' install.sh claim (opt-in/
   interactive, not automatic) and stale pre-opt-in comments in
   route_egress.go.
7. install.sh: Arch's ndppd install used pacman -Syu (full system
   upgrade) instead of -Sy like every other call in the script; and
   should_install_amneziawg re-prompted on every `x-ui update` even
   when awg was already installed.
8. CollectTraffic could clobber a concurrent restart's freshly-reset
   (empty) traffic baseline with stale pre-restart counters, since
   getPeerStats runs lock-free; now checks pointer identity before
   writing back. sweepOrphansLocked permanently disabled itself on a
   transient os.ReadDir failure instead of allowing a retry.

go build/vet/test and frontend typecheck/lint/build/vitest all pass.

* fix(install.sh): check the live sysctl value, not sysctl.conf text

Reviewer feedback (cherts, PR #6105): grepping /etc/sysctl.conf for the
setting name is unreliable -- many distros split sysctl config across
/etc/sysctl.d/*.conf, and /etc/sysctl.conf can be a symlink into that
directory, so the check can miss an already-active setting (harmless
duplicate append) or match a disabled/commented line (forwarding
silently stays off). Query the live value via `sysctl -n` instead,
which is accurate regardless of which file set it. Applied the same
fix to both the IPv6 and IPv4 checks for consistency.

* fix: update inbound_amneziawg.go to the split buildInboundForLocalRuntime

Same fork-only-file blind spot as the one caught on our own main after
the 3.6.0 sync: upstream split buildRuntimeInboundForAPI into
buildInboundForNodePush / buildInboundForLocalRuntime (part of the
node-sync client-deletion fix, 5bc81dfd), updating every call site it
could see. This file doesn't exist upstream, so it kept calling the
old name even after the branch merged in that commit.

* fix(frontend): recognize AmneziaWG's vpn:// scheme in share-link labels

The shared link-tag/label helper (used by the client info modal, QR
modal, and subscription page) had no entry for the vpn:// scheme
AmneziaWG links use, so it fell through to the generic fallback: a
plain "Vpn" tag with no color, and an empty remark/port that made the
row's title fall back to "Link N" instead of the inbound's actual
name:port — unlike every other protocol, which shows its real tag and
label.

vpn:// links are base64url of a plain .conf text (matching the real
AmneziaVPN app's own share-link format), not a structured URL, so
there's no query string or #hash to read a remark/port from. Decode
the payload and pull the remark/endpoint back out of the .conf text
directly instead.

* fix(xray): force a full restart for TPROXY inbounds, never hot-add them

Real incident: an AmneziaWG inbound with RouteThroughXray enabled lost
all internet on that connection after a migration. Root-caused on the
live box -- iptables TPROXY counters were incrementing (packets
correctly redirected to 127.0.0.1:63110), but nothing was actually
listening there (ss showed nothing on that port) until a full
`systemctl restart x-ui`, after which the bridge came up immediately.

Xray-core's gRPC AddInbound reports success for a new sockopt.tproxy
inbound (internal/amneziawg's own Xray egress bridge is the only kind
this fork ever generates) but doesn't reliably bind a working listener
for it outside of process startup -- the bridge silently never comes
up, and RouteThroughXray traffic goes nowhere until the next full
restart happens to occur for an unrelated reason.

diffInbounds already has this exact defensive pattern for REALITY
inbounds ("a gRPC remove+add does not reliably rebuild the REALITY
authenticator"), just never extended to TPROXY, and only in the
already-existing-then-changed branch -- the "brand new inbound" branch
had no such guard at all, which is exactly the path a freshly-enabled
RouteThroughXray bridge takes. Added inboundUsesTproxy and wired it
into both branches.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): flag Xray for resync when a peer edit changes qualifying state

Real production bug, root-caused on iiadmin-vps: updateAmneziaWGInbound/
AddInbound/DelInbound only ever updated the kernel interface via
amneziawg.GetManager() -- they never called SetNeedRestart the way every
other protocol's mutation path does (client_crud.go, inbound.go, etc. all
do). injectAmneziawgEgress's TPROXY bridge inbound depends on
InstanceFromInbound finding at least one qualifying peer plus
RouteThroughXray, so an edit that flips that (first peer added, last one
removed, RouteThroughXray toggled on) previously required a full panel
restart before the bridge actually got created, with no error anywhere:
the kernel interface would handshake fine, but traffic redirected into the
bridge's TPROXY port went nowhere because nothing was listening there.

diffInbounds/inboundUsesTproxy already correctly force a full restart for
a brand new TPROXY inbound (bdee0a20) -- that part was never the bug. The
gap was entirely upstream: nothing ever told Xray a resync was even needed.

* fix(clients): reject AllowedIPs already used on another WireGuard/AmneziaWG inbound

defaultWireguardClients/defaultAmneziaWGClients only ever checked uniqueness
against their own inbound's client list, so two inbounds sharing a subnet
(same protocol or not) could silently hand out or accept the same address --
the exact scenario behind a real duplicate-IP incident where a WireGuard and
an AmneziaWG client both ended up on the same address. otherTunnelAllowedIPs
now collects every address already claimed on every other tunnel inbound and
folds it into both the auto-allocation pool and the manual-entry collision
check, naming the other inbound in the error when it fires.

* fix(frontend): add the missing AmneziaWG config download on the sub page

The subscription page already gave WireGuard links their own "Config"
block (copy/download/QR of the actual .conf, via wireguardConfigFromLink
reversing the wireguard:// query params) but had no equivalent for
AmneziaWG's vpn:// links -- its isWireguardLink gate never matched them,
and no reverse-parse helper existed for this page specifically. Every
other surface (InboundInfoModal, ClientInfoModal, ClientQrModal) already
had this parity; this was the one page that didn't.

Fixed by adding amneziawgConfigFromLink (inbound-link.ts), simpler than
its WireGuard counterpart since a vpn:// payload already *is* the plain
.conf text -- just base64url-decode it, no query-param reconstruction
needed -- and wiring it into SubPage.tsx alongside the existing WireGuard
block, reusing the same pages.clients.amneziaWgConfig label the other
three surfaces already use.

* fix(xray): force a full restart for password-auth SOCKS5 hot-apply

Real production incident: editing a client under an AmneziaWG inbound
left its embedded SOCKS5 relay's settings byte-different (a new account
list), and Xray's gRPC remove+add hot swap silently dropped the account
for a peer whose email contained non-ASCII characters -- its tunnel kept
handshaking fine but all its traffic got rejected at the SOCKS5 layer,
while every other peer on the same relay was unaffected. A full restart
(reading the same JSON straight from disk) always produced the correct
account list. socks isn't in userDiffableProtocols (that only covers
vless/vmess/trojan's clients+email shape, not accounts+user), so any
settings drift on this inbound fell through to the generic remove+add
path. Forces a restart instead, the same defensive choice already made
for REALITY and TPROXY -- scoped to auth:"password" specifically so the
other, noauth SOCKS5 bridges (panel/node/mtproto egress) keep the cheaper
hot path.

* Fix Attach reusing one identity's address across wg/awg inbounds

ClientService.Attach deliberately copies one identity's stored
AllowedIPs into every WireGuard/AmneziaWG inbound it's attached to
in the same call, so the same person gets the same tunnel address
on every protocol they use. Its loop calls addInboundClient once per
inbound, and each of those independently computes
otherTunnelAllowedIPs -- so by the second inbound in the batch, the
first inbound's just-written copy of this identity's own address
looked like a cross-inbound collision against itself.

Real production symptom this caused: detaching then re-attaching a
client to both wg and awg failed with "wireguard: allowedIPs entry
X is already used by a client on inbound 'awg' (#N)" -- the exact
address the identity is supposed to keep, rejected as if it belonged
to someone else.

Add a selfEmails exclusion to otherTunnelAllowedIPs and populate it
from the client(s) being processed at the one real call site. Safe
unconditionally: ClientRecord.Email is globally unique, so a match
can only ever be this same identity's own entry on a sibling inbound,
never a genuine different client's address.

Reproduced the underlying mechanism live (manual entry correctly
rejected as a cross-inbound collision; fresh auto-allocation
correctly avoided a used address) before writing the fix, to confirm
the guard itself works and the bug is specifically in how Attach's
per-inbound calls interact with it.

* Attach: allocate fresh when re-attaching with no active tunnel

The previous fix (82cc69f5) made Attach's own address-reuse
correctly not collide with itself across inbounds -- but it still
always reused an identity's stored AllowedIPs verbatim, even when
that identity currently has zero WireGuard/AmneziaWG attachments at
all. A real report from testing this live: an identity fully
detached from both its wg and awg inbounds, then re-attached, got
its old address back even though several lower addresses were free
-- because nothing about being fully detached ever cleared the
stored value Attach copies from.

Add hasTunnelAttachment, checked once against the identity's CURRENT
inbound set before Attach's loop runs: if none of its current
inbounds is WireGuard/AmneziaWG, clear the stored AllowedIPs so this
attach allocates fresh (matching what a brand-new client would get)
instead of resurrecting an address nothing reserves anymore. Left
alone when the identity already has an active tunnel elsewhere, so
extending it to a second protocol still keeps a consistent address.

* Fix TestOtherTunnelAllowedIPsExcludesSelfEmail's own test setup

CI caught this: the "genuinely different client" (other@wg) was
seeded onto the SAME inbound passed as excludeID, which
otherTunnelAllowedIPs already excludes entirely regardless of the
selfEmails fix -- so the assertion that its address is still
reported could never have passed, proving nothing either way. Move
it onto the sibling inbound alongside shared@id, which is what the
test actually needs to exercise (two clients on one sibling, one
excluded by email, one not).

* Attach: never inherit an address that doesn't fit the target inbound

hasTunnelAttachment (from the earlier fix, commit 51067f16) only
asked "does this identity have ANY tunnel attachment", treating that
as license to reuse its stored address verbatim on every inbound
being attached. Real production case this missed: an identity's
stored address came from WireGuard's own fallback subnet
(10.0.0.0/24, used when that inbound has no other clients to infer a
base from), then got attached to a second, AmneziaWG inbound
configured for a completely different subnet (10.8.1.0/24).
defaultAmneziaWGClients's already-set-AllowedIPs branch only checks
for collisions, never subnet membership, so the mismatched address
was accepted silently -- producing a peer that can never actually
connect, since an AmneziaWG address must fall inside the kernel
interface's own configured subnet to be routable at all.

Add addressesFitAmneziaWGInbound, checked per inbound inside Attach's
loop: if the inherited address doesn't fit the SPECIFIC inbound being
attached, clear it just for that one so it gets a fresh, valid
allocation instead, while other already-attached inbounds keep their
existing values. WireGuard has no equivalent strict subnet
requirement (allocateWireguardAddress can widen to a fallback pool
for it), so this only ever constrains AmneziaWG targets.

* Give WireGuard an explicit, admin-configurable subnet field

WireGuard previously had no configurable subnet at all -- only an
implicit one, either inferred from existing clients' own addresses
(wireguardAllocationBase) or a hardcoded 10.0.0.0/24 fallback when
none exist yet. AmneziaWG, by contrast, has always had a real
server.subnetIp/subnetCidr field in its settings, editable in the
UI. User request: give WireGuard the same treatment.

Backend: explicitWireguardSubnetBase reads an optional subnetIp/
subnetCidr pair from the inbound's own settings JSON (mirroring
AmneziaWG's defaultAmneziaWGSubnetBases). defaultWireguardClients
checks it first; only when unset does it fall back to today's
inference-from-existing-clients behavior, so an inbound saved before
this field existed keeps working exactly as it always has.

Frontend: subnetIp/subnetCidr added to WireguardInboundSettingsSchema
and the inbound form (mirroring AmneziaWG's own field layout/labels),
with a real default (10.0.0.0/24, the same value the backend already
fell back to) seeded for newly created inbounds so the field starts
populated and editable rather than blank. Translated across all 13
locales.

This also structurally closes the class of bug fixed in
82cc69f5/291c47b3: with wg and awg subnets explicit and
independently controllable, an admin who wants matching addresses
across both protocols can configure them to actually agree, instead
of one silently inheriting the other's incompatible range.

* Split the client edit form's AllowedIPs into per-protocol fields

A client attached to both WireGuard and AmneziaWG shared one AllowedIPs
form field with a dynamically-switching label, so its two genuinely
different addresses could never both be shown or edited correctly.
Worse, Update/Create broadcast that one shared value to every attached
wg/awg inbound with no subnet-fit check, so an ordinary edit save could
silently overwrite one protocol's address with the other's -- the same
bug class already fixed for Attach, but reachable from any client edit.

model.Client gains an optional AllowedIPsByInbound map so a caller can
send distinct values per inbound; Update/Create honor it and, when it's
absent, clear a shared value that doesn't fit an AmneziaWG inbound's own
subnet instead of writing it through. A new TunnelAllowedIPsByInbound
read path feeds the real per-inbound address to the client edit form via
GET, which now renders two separate, correctly-labeled fields whenever
both protocols are attached (unchanged single dynamic field otherwise).

* Regenerate openapi.json for the new allowedIPsByInbound field

Follow-up to 878ee839: gen:zod (frontend/src/generated) was already
regenerated and committed, but gen:api (frontend/public/openapi.json)
wasn't, so CI's codegen drift check failed.

* Fix build breakage from merging upstream main: Update() gained a limitHwid param

Two of our own AllowedIPs tests (not present upstream, so the merge never
flagged them as conflicting) still called the old 3-arg Update(inboundSvc,
id, client) -- upstream's hardware-ID-limit feature added a required
limitHwid parameter that every other caller in this package already
passes. Also drop createDefaultInboundSettings from InboundsPage.tsx: the
merge conflict resolution kept the import, but upstream's clone-payload
refactor (buildClonePayload, inbound-clone.ts) already calls it
internally now -- this file doesn't need it directly anymore.

* Fix real bug: AmneziaWG clients rejected as "empty client ID" in 3 places

Three switch statements on inbound.Protocol handle "wireguard" explicitly
(checking client.PublicKey) but fall through to the default case for
"amneziawg" (checking client.ID, which AmneziaWG clients never set --
they use PublicKey/Email like WireGuard, not the VMess/VLESS UUID field).
This is what the 4 AllowedIPs tests were actually catching:
UpdateInboundClient's newClientId derivation hit this same default branch,
so every Update() on an AmneziaWG client returned "empty client ID"
before ever reaching the AllowedIPs logic being tested.

Fixed by adding "amneziawg" alongside "wireguard" in each switch:
addInboundClient's per-client validation, UpdateInboundClient's
newClientId derivation, and AddInbound's per-client validation (the
third one wasn't hit by these tests, but has the identical bug -- creating
a brand-new AmneziaWG inbound with a client attached would fail the
same way).

* refactor(amneziawg): rename Obfuscation20 to Obfuscation31, drop the dead mobile preset

Mechanical rename ahead of the AmneziaWG 3.1 parameter work: the type,
generator and prose all said 2.0, and the "mobile" generator preset was
reachable only from its own test. No behavior change.

* feat(amneziawg): AmneziaWG 3.1 obfuscation parameters (backend + generated schemas)

Adds the 3.1 parameter surface to the inbound settings and both Go config
emitters: I2-I5 signature packets, HeaderProtectionKey (base64 32-byte,
shared server<->client), ContentPaddingAddition, the five handshake-timing
randomization ranges (RekeyAfterTime/RekeyTimeout/RejectAfterTime/
KeepaliveTimeout/MaxHandshakeAttempts), and the RandomTrailers/
DisableCookies switches. Freshly generated sets fill everything except
I2-I5 (matching Amnezia's own generator) with jittered ranges bracketing
WireGuard's stock timing constants; every reject window starts >= 30s
above the rekey window by construction. Empty fields stay off the wire,
so blanking a field disables just that feature.

Validation generalizes the H1-H4 range checker for the new uint32-range
fields, requires min 1 on timers, cross-checks rekey-vs-reject, and
demands a real 32-byte base64 header-protection key. The manager warns
once per process when the installed awg tools predate 3.1 but an inbound
uses 3.1 parameters (awg-quick rejects unknown keys with a generic
error otherwise); apply still proceeds.

Requires amneziawg-tools v3.1.20260812+ / module or amneziawg-go
v3.1.20260814+ on the host.

* feat(amneziawg): emit and randomize 3.1 parameters in the frontend

Both client-config emitters (the vpn:// link builder and the clients-page
.conf builder) now carry the 3.1 [Interface] lines in the same order as
the Go emitters. The obfuscation randomizer moves out of InboundFormModal
into a shared lib/xray/amneziawg-obfuscation.ts that also fills the new
fields, and createDefaultAmneziawgInboundSettings switches from static
values to that generator — a fresh inbound now really gets the unique
fingerprint the docs promise instead of the same jc=5/jmin=10 set on
every install.

Schema parse-time defaults for the new fields stay ''/false on purpose:
real values come only from the generator, so resaving an inbound never
mutates its stored parameters. A new parity test pins the hand-written
AmneziawgServerSchema to the generated ServerSettings key set, so a field
added on one side can no longer silently vanish from configs.

* feat(amneziawg): 3.1 form fields and translations

Inbound form gains inputs for I2-I5, HeaderProtectionKey (filled by the
existing obfuscation Regenerate button), ContentPaddingAddition, the five
timing ranges, and the RandomTrailers/DisableCookies switches; the MTU
input picks up the min=1 its schema already enforced. All 13 locales get
the 19 new keys and drop the "2.0" branding from the s3/s4/i1 labels.

* docs(amneziawg): document 3.1 parameters; install.sh kernel/version notes

The AmneziaWG page's obfuscation section moves from the 2.0 to the 3.1
parameter set: table rows for I2-I5, HeaderProtectionKey,
ContentPaddingAddition, the timing-randomization ranges and the
RandomTrailers/DisableCookies switches, a requirements callout (tools
v3.1.20260812+, module/awg-go v3.1.20260814+, Linux 6.7+ for the DKMS
path), and a sample client .conf that matches what the panel actually
emits (including the DNS defaults and PersistentKeepalive it always had).

install.sh warns before a DKMS build on a pre-6.7 kernel and after any
install that left pre-3.1 amneziawg-tools on PATH.

Also updates the hosts API operation paths ({id} -> {groupId}) in the
stale ru/zh/fa reference pages: syncing docs/public/openapi.json for the
new AmneziaWG schema fields surfaced that rename, which had never been
copied over, and the docs build fails on paths missing from the spec.

* fix(amneziawg): reject control characters and canonicalize 3.1 range values

Adversarial review of the 3.1 work surfaced a validation gap:
base64.DecodeString silently ignores CR/LF, so a header-protection key
that picked up a line wrap in transit decoded to a valid 32 bytes,
passed validation, and was emitted verbatim into every client config —
where the orphan second line breaks the import while the server (whose
emitter strips control chars) keeps running with the correct key. The
key and range validators now reject control characters outright.

Also from the same review: range values are canonicalized on save
("110 - 140" -> "110-140", whitespace-only collapses to feature-off,
closing a case where the server conf rendered an invalid blank-value
line the client emitters omitted); the rekey/reject invariant is now
enforced against WireGuard's 120s/180s defaults when only one side is
set; and the structural fingerprint joins on "\n" instead of "|",
which is a legal I1-I5 character and made adjacent free-text fields
join-ambiguous.

* fix(install): resolve latest release tag via web redirect to dodge API rate limits

The non-interactive install smoke test resolved the release version through
the unauthenticated GitHub API (api.github.com/.../releases/latest), which
allows only 60 requests/hour per IP. The test installs twice in one run, and
on shared CI runner IPs the second call gets rate-limited, returns no
tag_name, and install.sh treats an empty version as fatal (exit 1) — the same
"Failed to fetch x-ui version" real users hit behind CGNAT/shared addresses.

resolve_latest_tag() now reads the tag from the github.com releases/latest
web redirect (not subject to the API rate limit), falling back to the API
only if the redirect yields nothing. Verified with the real
deploy/test/smoke-noninteractive.sh (two installs, both green).

* fix(amneziawg): three review findings on #6105, plus a comment trim

1. A peer's allowedIPs reached the generated .conf unvalidated and
   unsanitized, unlike email/publicKey/preSharedKey which
   normalizeAmneziaWGSettings already guards. A newline in an entry let a
   following "[Interface]" re-open the interface section, whose "PostUp = ..."
   awg-quick then runs as root on the next apply. Reproduced end to end
   against generateServerConfig. The save path now rejects and canonicalizes
   through normalizeWireguardAllowedIPs, and the render path sanitizes as a
   backstop for rows predating the validation (an upgrade, a restored backup,
   a direct DB edit). H1-H4 get the same render-time sanitize, and the two NIC
   name fields a plausibility check, since stripping control characters alone
   would still let a shell metacharacter into a root-executed PostUp line.

2. EgressPortForInbound is 63100 + inbound id, so an id past 2435 derives a
   port above 65535 -- and Xray rejects the whole generated config over one
   invalid port, taking every other protocol down with it. It now reports
   ok=false past the range, and both the Xray bridge and its TPROXY rules are
   skipped instead of emitting an impossible port.

3. The downloadable AmneziaWG .conf read ClientRecord.allowedIPs, a single
   shared column that holds the WireGuard address for an identity attached to
   both protocols -- the exact ambiguity tunnelAllowedIPs was added to resolve
   for the edit form. The info and QR modals already hydrate that field, so
   they now pass this inbound's own address to the builder.

Also trims the comment blocks in the files touched here to the 2-line
guidance in CLAUDE.md: internal/amneziawg alone carried 423 comment lines in
over-long blocks against 118 for the comparable internal/mtproto, and is now
at 110. Every non-obvious constraint is kept (the kernel S1/S2 rule, why
PostDown is best-effort, why grep -c and not -q, why the fingerprints split
three ways); the narration is gone. Two hot_diff.go comments pointed at an
internal/amneziawgnet package and an injectAmneziawgnetSocks function that
exist nowhere in the tree; the checks themselves are unchanged.

* feat(logs): add an AmneziaWG log view to the overview

The overview has an access-log view for Xray but nothing for AmneziaWG, so
when a tunnel misbehaves there is no way to see it from the panel at all. A
kernel tunnel logs no per-request lines, so the equivalent view is built from
the two things it does expose:

- Live per-peer activity from `awg show <iface> dump`, joined to the client
  email through the desired peer set: last handshake, endpoint, allowed IPs,
  cumulative transfer and online state, newest handshake first.
- The panel's own AmneziaWG event lines (interface up/down, awg-quick
  failures, the pre-3.1 tools warning), which are what actually explain a peer
  being absent from the table.

POST /panel/api/server/amneziawglogs/:count serves both, with the same
count + filter contract GetXrayLogs uses, and the modal mirrors XrayLogModal's
toolbar, auto-update, mobile cards and download. The action-bar button is
gated on a new status.amneziawg.configured, which stays true while an inbound
exists but its interface is down -- exactly when the event lines matter.

Verified against a running panel: the endpoint returns the peer table and
real event lines ("awg/awg-quick not found on PATH", "create config dir:
permission denied"), and count and filter both narrow as documented.

One of those lines surfaced a Debugf that had been rendering as
"for inbound1:amneziawg:"; fixed here since it is now user-visible.

* fix(amneziawg): stop double-counting a routed inbound's traffic

injectAmneziawgEgress tags its Xray bridge with the AmneziaWG inbound's own
tag, so the stock Routing page can target it. Xray therefore reports that
bridge's bytes under the inbound's tag, and XrayTrafficJob feeds them to
AddTraffic -- which accumulates -- on top of the same bytes AmneziaWGJob
already reported from `awg show dump`. An inbound with routeThroughXray on
counted roughly twice its real traffic, which also inflates the quota checks
that read the same counters.

The awg counters are the complete measure: every peer, whether or not TPROXY
routed it, and the same wire bytes the per-client totals are built from, so
they stay and the Xray rows are dropped. Per-client stats were never affected
-- a dokodemo-door bridge has no per-user identity, so Xray emits no
user>>>email rows for it.

Filtering happens before every consumer, so the DB totals, the external
traffic inform and the dashboard's live speed all read one source per inbound.
The set of bridge tags now comes from a predicate shared with
injectAmneziawgEgress itself, with a test that pins the two together -- naming
one tag too few doubles the traffic again, one too many makes real traffic
vanish.

* fix(amneziawg): align the three .conf emitters on one peer field order

The panel builds an AmneziaWG client .conf in three independent places, and
they disagreed: buildAmneziaWGClientConfig put PresharedKey right after
PublicKey (wg-quick(8)'s own order, and what both WireGuard emitters on the
clients side already use), while genAmneziaWGConfig and the Go
amneziaWGConfigText put it after Endpoint. A user comparing a subscription
link against a downloaded .conf sees the difference immediately, and the
generators are exactly the kind of parallel implementation CLAUDE.md warns
about drifting.

Moves the two outliers onto the wg-quick order. Also drops the stray trailing
newline that only appeared when PersistentKeepalive was set, so a config now
always ends on its last set field whichever that is -- the same shape all
three emitters produce for the same client.

Parsing is unaffected either way (the format is order-insensitive, and the
AmneziaVPN app reads it as a flat key-value bag), so this changes only the
rendered text. Adds a test on each side that pins the peer block's field
order, since nothing previously asserted it.

* refactor(amneziawg): switch to the embedded amneziawg-go/gVisor architecture

Replaces the kernel-module (DKMS) + awg-quick + TPROXY backend with the
fork's own embedded design: amneziawg-go runs in-process over a userspace
gVisor netstack, and each peer's decapsulated traffic relays into its own
loopback Xray SOCKS5 inbound, so Xray's native stats/sniffing/routing work
for free instead of through hand-rolled bridges. No kernel module, no DKMS,
no Secure Boot conflicts, works the same in a container as on bare metal.

- internal/amneziawgnet: new package (Device/UAPI, gVisor netstack, TCP/UDP
  forwarding, SOCKS5 relay, peer identity, IPv6 host-alias egress identity,
  per-client port-forwarding) - amneziawg-go v3.1.20260814 + gvisor.
- internal/amneziawg: keep the reusable protocol-shape types/validation
  (Instance/Peer/Obfuscation, InstanceFromInbound); drop the OS-shellout
  half (awg-quick, TPROXY policy routing, NDP proxy, peer-stats parsing).
- internal/web/service: rewire the 5 integration points (job, runtime,
  client-apply, web shutdown, xray config) from the old manager to the new
  one; the AmneziaWG log view is rebuilt on the embedded Device's own UAPI
  dump (extended to carry endpoint/AllowedIPs) instead of `awg show dump`.
- install.sh: drop DKMS/ndppd/TPROXY/Secure-Boot installer code (~250
  lines) - an entire recurring class of installer fragility goes away.
- frontend: drop the now-meaningless routeThroughXray toggle (the relay is
  always on); keep the field in the Zod schema, unexposed, so it isn't
  silently stripped from stored settings on next save - two regression
  tests deliberately depend on the Go struct still carrying it.
- docs/i18n: rewrite amneziawg.mdx for the new architecture; drop the
  dead routeThroughXray translation keys across all 13 locales.

Real production throughput (embedded core datapath, isolated bench, same
box the kernel-module path was measured on): ~296 Mbit/s up, ~640 Mbit/s
down, vs. 414.69 MB/s (~3.3 Gbit/s) for the kernel module on the same
hardware - a real gap, tempered by this being single-stream/no-SOCKS5-hop
and most VPN traffic being latency-bound rather than throughput-saturating.

* fix(amneziawg): restore the branch's own Obfuscation31 shape + 2 CodeQL findings

The previous push's wholesale-copy of types.go/params.go from the fork's
main branch pulled in that branch's own independent (and incompatible)
naming for the same AWG 3.1 feature set: Obfuscation20/GenerateObfuscation20
instead of this branch's already-shipped Obfuscation31/GenerateObfuscation31,
and a missing CanonicalizeUintRange -- broke every Go CI job (the whole
matrix fails to compile when any one package doesn't, which is why govulncheck/
golangci/postgres-durable-first/race all failed identically, not just go-test).

Restores params.go/params_test.go verbatim from this branch's own last
commit (a strict superset of validation: it already cross-checks rekey vs.
reject timing windows, which the copied version never did) and folds the
3.0/3.1 fields (HeaderProtectionKey, ContentPaddingAddition, the 5 timing
fields, RandomTrailers/DisableCookies) into Obfuscation31 itself, matching
the original struct exactly instead of as separate top-level Instance
fields. instance.go, the two amneziawgnet call sites, and 7 amneziawgnet
test files updated to match. Also drops the one test (sanitizeConfigValue)
that only ever served the retired kernel-module .conf writer -- correctly
not ported, so the test testing it shouldn't have been copied either.

Also fixes 2 CodeQL findings the same push surfaced: a clamped uint64->int64
conversion for the new log view's live byte counters (server.go), and an
unneeded len+len sum feeding a slice pre-size in the v6-egress outbound
merge (xray.go) -- append already grows correctly without it.

* chore(amneziawg): regenerate frontend schemas for updated doc comments

npm run gen was missed after the previous commit's types.go doc-comment
edits (Obfuscation20 -> Obfuscation31, ValidateHeaderProtection ->
ValidateObfuscation in the prose) -- openapigen bakes those comments
into the generated schema's description field, so the committed
frontend/src/generated/schemas.ts and openapi.json still had the old
wording. codegen's git-diff-exit-code check caught it correctly.

* fix(amneziawg): narrow 2 test fixtures that collided with MaxForwardedPorts

TestCheckForwardedPortsConflict_CollidesWithEnabledInboundPort and
..._NoCollisionWhenPortsDontOverlap used "8000-8100"/"9000-9100" as their
ForwardedPorts fixture -- 101 ports each, one over MaxForwardedPorts (100).
The cap check (checkForwardedPortsConflict, added this session alongside
the SOCKS-phantom-port check) fires first, so both tests got "more than
100 forwarded ports" instead of ever reaching the collision logic they're
actually testing. The cap itself has its own dedicated boundary test
already; these two just needed a narrower range that still covers/misses
port 8080 as intended -- 8075-8085 and 9075-9085, 11 ports each.

* fix(amneziawg): checkAmneziawgnetSocksConflict had no receiver in its new home

My merge-conflict resolution kept this as a method call (s.checkAmneziawgnetSocksConflict)
inside checkPortConflictTx, a plain function with no *InboundService receiver --
upstream's #6225 fix moved the port-conflict check out of the (s *InboundService)
method and into this new tx-scoped free function, and I didn't notice the call
site needed to change shape too. CI caught it immediately (undefined: s); nothing
in this specific package can be locally verified past internal/database's own
unrelated, pre-existing CGO build issue on this dev machine.

Since the signature had to change either way, folded in the fix already flagged
as a separate follow-up: checkAmneziawgnetSocksConflict now takes the caller's
db handle instead of fetching its own via database.GetDB(), so it actually runs
inside the same serialized transaction #6225 introduced -- previously it sat
right next to that race fix without benefiting from it.

* fix: address the review findings on the embedded AmneziaWG PR

5 blocking findings:

- Floor S3/S4 at 12 in both obfuscation generators (Go and frontend) and
  reject a hand-edited value below that when HeaderProtectionKey is set --
  IpcSet requires it, and ~39% of previously-generated sets violated it
  silently.
- Guard PrivateKey/PrimaryDNS/SecondaryDNS/remark against newline injection
  in the AmneziaWG .conf builder (both the Go subscription-link path and
  the frontend downloadable-config path) -- unguarded, any of them could
  inject an arbitrary config line into a subscriber's client.
- Bound the derived AmneziaWG SOCKS relay port to <= 65535 once an
  inbound's id is known, and check the reverse direction (does the relay
  port collide with an existing inbound's port) on both create and update
  -- previously only port -> relay collisions were checked, not relay ->
  port.
- Gate injectAmneziawgV6Egress on the same V6AliasesActive predicate
  desiredV6Aliases already uses, so the two can't disagree about whether a
  peer's IPv6 identity is actually active at the OS level.

2 minor findings:

- Fix the forwarded-ports cap check's off-by-one (a spec covering exactly
  the cap was rejected as if it were over it).
- Correct docker-compose.yml's stale comment describing the retired
  DKMS/kernel-module architecture.

* chore: retrigger CI

build (armv5) failed on a transient Go module proxy network error
(INTERNAL_ERROR stream reset on sagernet/sing), unrelated to this PR's
changes.

* docs: fix doc comments still describing the retired DKMS/awg-quick design

A few doc comments (and one illustrative test log line) survived the
embedded-architecture cutover unchanged and now contradict the code
they sit next to:

- internal/amneziawg/types.go's package comment claimed this package
  still owns a Manager that reconciles OS-level interfaces via
  awg-quick/DKMS -- that Manager was removed; the reconcile loop lives
  in internal/amneziawgnet now, and this package is protocol-shape-only.
- internal/amneziawg/params.go's ValidateObfuscation/ValidateConfigValue
  comments cited "awg-quick up" / "awg-quick executes as root" as the
  reason to validate -- the server itself never calls awg-quick in this
  architecture; the same value still reaches a real rendered .conf that
  a client app or an admin's own awg-quick CLI applies downstream, so
  the validation is still warranted, just for a different consumer.
  Mirrored the same fix in inbound_amneziawg.go's matching comment and
  its test's comment.
- internal/amneziawgnet/manager.go's Manager doc comments (x3) pointed
  readers at "internal/amneziawg.Manager" for comparison -- that type no
  longer exists in this diff at all. Repointed at internal/mtproto.Manager,
  the pattern this was actually modeled on and the one that's still real.
- Swapped one test's illustrative "awg-quick up awg2 failed" log line for
  a message shaped like this architecture's actual amneziawgnet logging,
  so a reader skimming the test doesn't wonder whether the server still
  shells out to awg-quick.

No behavior change.

* fix(docs): re-run codegen for xray-settings.mdx after conflict merge

The automated conflict-resolution hand-merge for this generated file
was content-correct but didn't byte-match a real regen (different
YAML long-string folding style). Re-ran npm run gen + docs' gen:api
and kept that canonical output instead.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): drop the dead access-log email backfill

amneziawgEmailIndex keyed peers by "<tag>|<tunnel IP>", a scheme built
for the retired TPROXY bridge where the peer's decapsulated tunnel
address survived as the access log's from-address. The embedded
architecture relays through a loopback SOCKS5 dial, so every AmneziaWG
log line's from-address is 127.0.0.1:<ephemeral> and the lookup could
never match: the index was rebuilt on every log view just to miss.
Remove the index, its GetXrayLogs wiring and its test. If per-line
emails are wanted back, the relay would have to publish a
local-port->email registry for the viewer to resolve loopback sources.

* fix(api): generate AmneziaWGLogs/PeerActivity schemas instead of hand-writing them

The amneziawglogs endpoint's response structs were missing from
openapigen's StructAllow, so they were silently absent from every
generated schema/example, the endpoints.ts entry carried a hand-written
response, and AmneziaWGLogModal.tsx duplicated the shapes as local
interfaces - the exact drift the allowlist rule exists to prevent.
Allowlist both structs with example tags, point the endpoint at the
generated schema, import the generated types in the modal, and sync
docs/public/openapi.json.

* chore(amneziawg): drop the unreferenced quiccapture package

Nothing imports internal/amneziawg/quiccapture and no route exposes it;
its package doc justifies the code as a port of
frontend/src/lib/xray/i1Generators.ts, which does not exist in this
repository, and promises an API round-trip that also does not exist.
1,110 lines of unreachable code with misleading provenance claims.
Revert this commit to bring the package back when the live-capture I1
feature and its frontend counterpart actually land.

* fix(clients): re-run cross-inbound conflict checks on the serialized writer

The new client-level checks - cross-inbound AllowedIPs collisions and
AmneziaWG forwardedPorts conflicts - read a fresh DB snapshot, decide,
and only then enter runSerializedTx, while lockInbound only serializes
writers on the SAME inbound. Two concurrent client creates on two
different tunnel inbounds both passed the read and both committed,
yielding two peers with one address: the exact check-then-claim race
81cfd857 (#6225) closed for AddInbound, which this PR's own
checkAmneziawgnetSocksReverseConflict already cites. Keep the pre-tx
pass for fail-fast UX and re-validate inside the transaction, where the
single writer makes the answer authoritative. The race test drives two
goroutines at two inbounds and demands exactly one winner; it fails
with committed=2 when the in-tx re-check is removed.

* fix(amneziawg): hot-apply depletion disables like mtproto does

applyTrafficMutationBatch special-cases MTProto so a quota/expiry
depletion cuts the sidecar immediately, but AmneziaWG fell through to
runtime AddUser/RemoveUser - explicit no-ops for this protocol - so a
depleted peer kept tunneling until the next 10s reconcile tick. Route
it through applyLocalAmneziaWG, whose own contract (re-read committed
settings, filter depleted clients, push to the interface) is exactly
this case; the comment claiming it mirrors applyLocalMtproto is now
true for the depletion path too.

* fix(amneziawg): persist cleared DNS fields instead of resurrecting defaults

PrimaryDNS/SecondaryDNS marshaled with omitempty, so clearing them
persisted settings with no key at all - and the frontend re-parses
stored settings through a Zod schema whose .default('8.8.8.8') /
.default('8.8.4.4') fire on missing keys, silently repopulating the
form on every load and re-persisting the defaults on the next save.
Blank is a documented, meaningful state (no DNS line in client
configs); drop omitempty so a cleared value survives the round-trip.
The regression test normalizes a server block with cleared DNS and
fails when the keys are dropped.

* fix(amneziawg): accept cleared numeric obfuscation/subnet fields in the form

AntD InputNumber emits null when cleared, Zod .default() only replaces
undefined, and unlike wireguard.ts - whose optionalClearedInt comment
documents exactly this failure mode - the AmneziaWG schema declared
subnetCidr and jc/jmin/jmax/s1-s4 as bare z.number() defaults. Clearing
any of the eight fields made safeParse reject the null and block the
save until the user retyped a value. Absorb null into undefined while
keeping each field's schema default, so a cleared field refills its
documented default and legacy blobs with absent keys behave as before.

* fix(amneziawg): guard the third .conf emitter against newline injection

The review-round fix added the newline guard to amneziaWGConfigText (Go)
and buildAmneziaWGClientConfig, but genAmneziaWGConfig in inbound-link.ts
- the third of the three emitters its own comment says must not drift -
still rendered privateKey/primaryDns/secondaryDns/remark unescaped, so a
newline there injected a config line (e.g. a rogue PostUp) into the
inbound form's downloaded .conf. Add the same guard, plus the regression
tests the original fix shipped without: all four fields on the Go and
both frontend emitters go red if any guard is removed.

* test(amneziawg): pin the S3/S4 floors the TS drift guard claims to mirror

The test's docstring says it mirrors internal/amneziawg/params_test.go,
but it asserted S3>=8/S4>=4 while the Go test and both generators pin
12/12 - the floor ValidateObfuscation enforces whenever a header
protection key is set, which this generator always sets. A regression
narrowing the TS floors into 8-11/4-11 would have passed the drift
guard and produced configs the backend rejects on save.

* docs: restore the pia repo-map entry and document the AmneziaWG subsystem

Merging main dropped CLAUDE.md's internal/pia/ bullet (added by #6272)
while resolving the repo-map conflict - the package itself is untouched.
Restore it, add the missing map entries for the two packages this branch
introduces (internal/amneziawg/, internal/amneziawgnet/), bump the cron
count, and give amneziawg_job its row in architecture.md's 5.4 table.

* chore(amneziawg): correct comments stranded by the architecture pivot

ae77c7e9's cutover to the embedded gVisor path deleted the kernel-module
code but left several comments describing it in the present tense:
hot_diff.go cited the removed service.amneziawgEgressStreamSettings and
wrongly claimed AmneziaWG is the only sockopt.tproxy source (tunnel's
TProxy mode is the live one the guard protects), socks_config.go pointed
at the deleted EgressBasePort/EgressPortForInbound, manager.go referred
to the deleted Manager and its fingerprinting as live code, web.go's
cron registration claimed the job scrapes traffic (its own doc says it
does not), and types.go capped ContentPaddingAddition at uint16 when
validation and upstream both use uint32.

* style(lint): satisfy gofumpt/goimports so make verify is green

json_service.go's two 'Tag: "proxy"}' literals came in with main's own
cc245a90 formatting commit and fail the repo's gofumpt gate for everyone;
the import grouping in inbound_amneziawg.go is from the serialized-writer
fix on this branch.

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Sanaei <ho3ein.sanaei@gmail.com>
Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
2026-08-24 02:41:15 +02:00

2253 lines
133 KiB
JSON
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
{
"username": "Nome de Usuário",
"password": "Senha",
"login": "Entrar",
"confirm": "Confirmar",
"cancel": "Cancelar",
"close": "Fechar",
"save": "Salvar",
"logout": "Sair",
"create": "Criar",
"add": "Adicionar",
"remove": "Remover",
"update": "Atualizar",
"copy": "Copiar",
"copied": "Copiado",
"more": "mais",
"download": "Baixar",
"regenerate": "Regenerar",
"jsonEditor": "Editor JSON",
"downloadImage": "Baixar imagem",
"sort": "Ordenar",
"remark": "Observação",
"enable": "Ativado",
"protocol": "Protocolo",
"search": "Pesquisar",
"filter": "Filtrar",
"all": "Todos",
"from": "De",
"to": "Até",
"done": "Concluído",
"loading": "Carregando...",
"refresh": "Atualizar",
"clear": "Limpar",
"second": "Segundo",
"minute": "Minuto",
"hour": "Hora",
"day": "Dia",
"check": "Verificar",
"indefinite": "Indeterminado",
"unlimited": "Ilimitado",
"none": "Nenhum",
"qrCode": "Código QR",
"info": "Mais Informações",
"edit": "Editar",
"delete": "Excluir",
"reset": "Redefinir",
"noData": "Sem dados.",
"copySuccess": "Copiado com Sucesso",
"sure": "Certo",
"encryption": "Criptografia",
"transmission": "Transmissão",
"host": "Host",
"path": "Caminho",
"camouflage": "Ofuscação",
"status": "Status",
"enabled": "Ativado",
"disabled": "Desativado",
"depleted": "Encerrado",
"depletingSoon": "Esgotando",
"offline": "Offline",
"online": "Online",
"domainName": "Nome de Domínio",
"monitor": "IP de Escuta",
"certificate": "Certificado Digital",
"fail": "Falhou",
"comment": "Comentário",
"success": "Com Sucesso",
"lastOnline": "Última vez online",
"lastSubFetch": "Última busca da assinatura",
"getVersion": "Obter Versão",
"install": "Instalar",
"clients": "Clientes",
"usage": "Uso",
"twoFactorCode": "Código",
"remained": "Restante",
"security": "Segurança",
"emptyDnsDesc": "Nenhum servidor DNS adicionado.",
"emptyFakeDnsDesc": "Nenhum servidor Fake DNS adicionado.",
"emptyBalancersDesc": "Nenhum balanceador adicionado.",
"somethingWentWrong": "Algo deu errado",
"subscription": {
"title": "Informações da assinatura",
"subId": "ID da assinatura",
"status": "Status",
"downloaded": "Baixado",
"uploaded": "Enviado",
"expiry": "Validade",
"totalQuota": "Cota total",
"individualLinks": "Links individuais",
"active": "Ativo",
"inactive": "Inativo",
"unlimited": "Ilimitado",
"noExpiry": "Sem validade",
"copyAllConfigs": "Copiar Todas as Configurações",
"copyAllConfigsCopied": "Todas as configurações copiadas",
"email": "Email"
},
"menu": {
"theme": "Tema",
"dashboard": "Visão Geral",
"inbounds": "Entradas",
"clients": "Clientes",
"groups": "Grupos",
"nodes": "Nós",
"settings": "Configurações do Painel",
"xray": "Configurações Xray",
"routing": "Roteamento",
"outbounds": "Saídas",
"apiDocs": "Documentação da API",
"donate": "Doar",
"hosts": "Hosts",
"docs": "Documentação",
"openMenu": "Abrir menu",
"pinSidebar": "Fixar barra lateral",
"unpinSidebar": "Desafixar barra lateral",
"subFormats": "Sub Formats"
},
"pages": {
"login": {
"hello": "Olá",
"title": "Bem-vindo",
"loginAgain": "Sua sessão expirou, faça login novamente",
"toasts": {
"invalidFormData": "O formato dos dados de entrada é inválido.",
"emptyUsername": "Nome de usuário é obrigatório",
"emptyPassword": "Senha é obrigatória",
"wrongUsernameOrPassword": "Nome de usuário, senha ou código de dois fatores inválido.",
"successLogin": "Você entrou na sua conta com sucesso."
}
},
"index": {
"cpu": "CPU",
"swap": "Swap",
"storage": "Armazenamento",
"memory": "Memória",
"xrayStatus": "Xray",
"stopXray": "Parar",
"restartXray": "Reiniciar",
"xraySwitch": "Versão",
"xrayUpdates": "Atualizações do Xray",
"xraySwitchClickDesk": "Escolha com cuidado, pois versões mais antigas podem não ser compatíveis com as configurações atuais.",
"updatePanel": "Atualizar painel",
"panelUpdateDesc": "Isso atualizará o 3X-UI para a versão mais recente e reiniciará o serviço do painel.",
"currentPanelVersion": "Versão atual do painel",
"latestPanelVersion": "Última versão do painel",
"panelUpToDate": "O painel está atualizado",
"devChannel": "Canal de desenvolvimento",
"devChannelWarning": "As builds de desenvolvimento acompanham cada commit na main e não são versões estáveis — não há downgrade automático.",
"currentCommit": "Commit atual",
"latestCommit": "Último commit",
"updateChannelChanged": "Canal de atualização alterado",
"xrayStatusUnknown": "Desconhecido",
"xrayStatusRunning": "Em execução",
"xrayStatusStop": "Parado",
"xrayStatusError": "Erro",
"systemHistoryTitle": "Histórico do Sistema",
"historyTitleCpu": "Uso da CPU",
"historyTitleMem": "Uso de Memória",
"historyTitleNetwork": "Largura de Banda da Rede",
"historyTitlePackets": "Pacotes de Rede",
"historyTitleDisk": "E/S de Disco",
"historyTitleOnline": "Clientes Online",
"historyTitleLoad": "Média de Carga do Sistema (1 / 5 / 15 min)",
"historyTitleConnections": "Conexões Ativas (TCP / UDP)",
"historyTitleDiskUsage": "Uso do Espaço em Disco",
"historyTabBandwidth": "Largura de Banda",
"historyTabPackets": "Pacotes",
"historyTabDisk": "Disco I/O",
"historyTabOnline": "Online",
"historyTabLoad": "Carga",
"historyTabConnections": "Conexões",
"historyTabDiskUsage": "Uso de Disco",
"xrayMetricsTitle": "Métricas do Xray",
"xrayTitleHeap": "Memória Heap Alocada",
"xrayTitleSys": "Memória Reservada do SO",
"xrayTitleObjects": "Objetos Heap Ativos",
"xrayTitleGcCount": "Ciclos de GC Concluídos",
"xrayTitleGcPause": "Duração da Pausa do GC",
"xrayTitleObservatory": "Saúde das Conexões de Saída",
"xrayTabHeap": "Heap",
"xrayTabSys": "Sys",
"xrayTabObjects": "Objetos",
"xrayTabGcCount": "Contagem GC",
"xrayTabGcPause": "Pausa GC",
"xrayTabObservatory": "Observatório",
"xrayMetricsDisabled": "Endpoint de métricas do Xray não configurado",
"xrayMetricsHint": "Adicione um bloco metrics de nível superior à configuração do xray com tag metrics_out e listen 127.0.0.1:11111, depois reinicie o xray.",
"xrayObservatoryEmpty": "Ainda não há dados do Observatory",
"xrayObservatoryHint": "Adicione um bloco observatory à configuração do xray listando as tags de outbound a sondar, depois reinicie o xray.",
"xrayObservatoryTagPlaceholder": "Selecionar outbound",
"xrayObservatoryAlive": "Ativo",
"xrayObservatoryDead": "Inativo",
"xrayObservatoryLastSeen": "Visto pela última vez",
"xrayObservatoryLastTry": "Última tentativa",
"connectionCount": "Estatísticas de Conexão",
"ipAddresses": "Endereços IP",
"toggleIpVisibility": "Alternar visibilidade do IP",
"overallSpeed": "Velocidade geral",
"upload": "Upload",
"download": "Download",
"sent": "Enviado",
"received": "Recebido",
"xraySwitchVersionDialog": "Você realmente deseja alterar a versão do Xray?",
"xraySwitchVersionDialogDesc": "Isso mudará a versão do Xray para #version#.",
"xraySwitchVersionPopover": "Xray atualizado com sucesso",
"panelUpdateDialog": "Deseja realmente atualizar o painel?",
"panelUpdateDialogDesc": "Isso atualizará o 3X-UI para #version# e reiniciará o serviço do painel.",
"panelUpdateStartedPopover": "Atualização do painel iniciada",
"panelUpdateFailedTitle": "Falha ao atualizar o painel",
"panelUpdateFailedDesc": "A atualização não foi concluída com sucesso. Verifique os logs do servidor ou execute 'x-ui update' na linha de comando.",
"panelUpdateUnknownTitle": "Não foi possível confirmar se a atualização terminou",
"panelUpdateUnknownDesc": "O painel não retornou um resultado a tempo. Recarregue a página para verificar a versão atual, ou verifique os logs do servidor.",
"geofileUpdateDialog": "Você realmente deseja atualizar o geofile?",
"geofileUpdateDialogDesc": "Isso atualizará o arquivo #filename#.",
"geofilesUpdateDialogDesc": "Isso atualizará todos os arquivos.",
"geofilesUpdateAll": "Atualizar tudo",
"geofileUpdatePopover": "Geofile atualizado com sucesso",
"geodataTitle": "Atualização automática de Geodata",
"geodataHint": "O Xray baixa esses arquivos conforme o agendamento e os recarrega sem reiniciar. As URLs devem ser HTTPS. Cada arquivo já deve existir na pasta bin para que o Xray possa atualizá-lo.",
"geodataCron": "Agendamento (cron)",
"geodataOutbound": "Baixar através de outbound (opcional)",
"geodataFile": "Nome do arquivo",
"geodataAddFile": "Adicionar arquivo",
"geodataSaveRestart": "Salvar e reiniciar o Xray",
"geodataConfirmTitle": "Salvar configurações de geodata?",
"geodataConfirmContent": "O modelo de configuração do Xray será atualizado e o Xray será reiniciado.",
"geodataInvalidUrl": "Cada arquivo precisa de uma URL HTTPS.",
"geodataInvalidFile": "O nome do arquivo deve ser simples, ex.: geosite_custom.dat (sem caminhos).",
"geodataInvalidCron": "O cron deve ter 5 campos, ex.: 0 4 * * *",
"geodataEmpty": "Nenhum arquivo configurado. Nas regras de roteamento, referencie como ext:geosite_custom.dat:category.",
"dontRefresh": "Instalação em andamento, por favor não atualize a página",
"logs": "Logs",
"accessLogs": "Logs de acesso",
"autoUpdate": "Atualização automática",
"amneziawgLogs": "Logs do AmneziaWG",
"amneziawgHandshake": "Último handshake",
"amneziawgInterface": "Interface",
"amneziawgInbound": "Entrada",
"amneziawgEndpoint": "Endpoint",
"amneziawgIdle": "Ocioso",
"amneziawgEvents": "Eventos",
"amneziawgNoPeers": "Nenhum peer do AmneziaWG está ativo",
"amneziawgNoEvents": "Nenhum evento do AmneziaWG registrado ainda",
"config": "Configuração",
"backupTitle": "Backup & Restauração",
"exportDatabase": "Backup",
"exportDatabaseDesc": "Clique para baixar um arquivo .db contendo um backup do seu banco de dados atual para o seu dispositivo. O mesmo arquivo também pode ser restaurado em um painel executando PostgreSQL.",
"importDatabase": "Restaurar",
"importDatabaseDesc": "Clique para selecionar e enviar um backup .db ou um dump de migração (.dump) do seu dispositivo para restaurar seu banco de dados.",
"importDatabaseSuccess": "O banco de dados foi importado com sucesso",
"importDatabaseError": "Ocorreu um erro ao importar o banco de dados",
"readDatabaseError": "Ocorreu um erro ao ler o banco de dados",
"getDatabaseError": "Ocorreu um erro ao recuperar o banco de dados",
"getConfigError": "Ocorreu um erro ao recuperar o arquivo de configuração",
"backupPostgresNote": "Este painel é executado em PostgreSQL. «Backup» baixa um arquivo pg_dump (.dump) e «Restaurar» o recarrega com pg_restore. «Restaurar» também aceita um banco de dados SQLite (.db) ou um dump de migração do SQLite e importa seus dados para o PostgreSQL. O servidor precisa ter as ferramentas cliente do PostgreSQL (pg_dump e pg_restore) instaladas.",
"exportDatabasePgDesc": "Clique para baixar um dump do PostgreSQL (.dump) do seu banco de dados atual para o seu dispositivo.",
"importDatabasePgDesc": "Clique para selecionar e enviar um backup do PostgreSQL (.dump), um banco de dados SQLite (.db) ou um dump de migração do SQLite para restaurar seu banco de dados. Isso substitui todos os dados atuais.",
"migrationDownload": "Baixar migração",
"migrationDownloadPgDesc": "Clique para baixar um banco de dados SQLite .db criado a partir dos seus dados do PostgreSQL, pronto para executar este painel no SQLite.",
"avg": "média",
"peak": "pico",
"free": "livre",
"openSockets": "sockets abertos",
"throughputSub": "Total da interface",
"avgWindow": "Média do período",
"healthWarm": "{list} — um pouco alto",
"healthCritical": "{list} — crítico",
"panel": "Painel",
"threads": "Threads",
"uptime": "Tempo ativo",
"logLevelDebug": "Debug",
"logLevelInfo": "Info",
"logLevelNotice": "Notice",
"logLevelWarning": "Warning",
"logLevelError": "Error",
"accessDirect": "DIRECT",
"accessBlocked": "BLOCKED",
"accessProxy": "PROXY",
"importKeepHostSettings": "Manter as configurações desta máquina",
"importKeepHostSettingsDesc": "Mantém os endereços de escuta, as portas, o caminho base, os certificados e a identidade de nó deste painel em vez de obtê-los do arquivo enviado."
},
"inbounds": {
"totalDownUp": "Total Enviado/Recebido",
"totalUsage": "Uso Total",
"inboundCount": "Total de Inbounds",
"operate": "Menu",
"enable": "Ativado",
"remark": "Observação",
"node": "Nó",
"deployTo": "Implantar em",
"localPanel": "Painel local",
"fallbacks": {
"title": "Fallbacks",
"empty": "Ainda sem fallbacks",
"add": "Adicionar fallback",
"pickInbound": "Escolha um inbound",
"matchAny": "qualquer",
"destPlaceholder": "automático (listen:porta do filho)",
"needsTls": "Os fallbacks ficam disponíveis após selecionar TLS ou Reality na aba Segurança (apenas VLESS/Trojan sobre RAW)."
},
"protocol": "Protocolo",
"port": "Porta",
"portMap": "Mapeamento de portas",
"traffic": "Tráfego",
"speed": "Velocidade",
"expireDate": "Duração",
"createdAt": "Criado",
"updatedAt": "Atualizado",
"resetTraffic": "Redefinir tráfego",
"addInbound": "Adicionar Inbound",
"generalActions": "Ações Gerais",
"modifyInbound": "Modificar Inbound",
"deleteConfirmTitle": "Excluir o inbound \"{remark}\"?",
"deleteConfirmContent": "Isto remove o inbound e todos os seus clientes. Não é possível desfazer.",
"resetConfirmTitle": "Redefinir o tráfego de \"{remark}\"?",
"resetConfirmContent": "Zera os contadores de envio/recebimento para este inbound.",
"selectedCount": "{count} selecionado(s)",
"selectAll": "Selecionar tudo",
"bulkDeleteConfirmTitle": "Excluir {count} inbounds?",
"bulkDeleteConfirmContent": "Isto remove os inbounds selecionados e todos os seus clientes. Não é possível desfazer.",
"cloneConfirmTitle": "Clonar o inbound \"{remark}\"?",
"cloneConfirmContent": "Cria uma cópia com uma nova porta e lista de clientes vazia.",
"delAllClients": "Excluir todos os clientes",
"delAllClientsConfirmTitle": "Excluir todos os {count} clientes de \"{remark}\"?",
"delAllClientsConfirmContent": "Remove todos os clientes deste inbound e descarta seus registros de tráfego. O inbound em si é mantido. Esta ação não pode ser desfeita.",
"attachClients": "Associar clientes a…",
"addClientsToGroup": "Adicionar clientes ao grupo…",
"attachClientsTitle": "Associar clientes de «{remark}»",
"attachClientsDesc": "Associa os mesmos {count} cliente(s) (mesmo UUID/senha e tráfego compartilhado) à(s) entrada(s) selecionada(s). Permanecem nesta entrada também.",
"attachClientsTargets": "Entradas de destino",
"attachClientsNoTargets": "Não há outras entradas compatíveis disponíveis para associação.",
"attachClientsResult": "Associados {attached}, ignorados {skipped}.",
"attachClientsResultMixed": "Associados {attached}, ignorados {skipped}, erros {errors}.",
"attachClientsSelectLabel": "Clientes para associar",
"attachClientsSearchPlaceholder": "Buscar email ou comentário",
"attachClientsStatusDisabled": "Desabilitado",
"attachClientsSelectedCount": "{selected} de {total} selecionado(s)",
"attachExistingClients": "Associar clientes existentes…",
"attachExistingTitle": "Associar clientes existentes a «{remark}»",
"attachExistingDesc": "Associa os clientes existentes ({count} disponíveis) a esta entrada — mesmo UUID/senha e tráfego compartilhado. Clientes que já estão nela são ignorados.",
"attachExistingNoClients": "Ainda não há clientes. Crie clientes primeiro e depois associe-os aqui.",
"attachExistingStatusAttached": "Já associado",
"detachClients": "Desassociar clientes",
"detachClientsTitle": "Desassociar clientes de «{remark}»",
"detachClientsDesc": "Remove o(s) cliente(s) selecionado(s) apenas desta entrada. Os registros são mantidos (use Delete para remover completamente). A origem tem {count} cliente(s) no total.",
"detachClientsResult": "Desassociados {detached}, ignorados {skipped}.",
"detachClientsResultMixed": "Desassociados {detached}, ignorados {skipped}, erros {errors}.",
"detachClientsSelectLabel": "Clientes para desassociar",
"exportLinksTitle": "Exportar links do inbound",
"exportSubsTitle": "Exportar links de assinatura",
"exportAllLinksTitle": "Exportar todos os links de inbound",
"exportAllSubsTitle": "Exportar todos os links de assinatura",
"exportAllLinksFileName": "Todas-as-entradas",
"exportAllSubsFileName": "Todas-as-entradas-Subs",
"inboundJsonTitle": "JSON da entrada",
"resetTrafficContent": "Tem certeza de que deseja redefinir o tráfego?",
"copyLink": "Copiar URL",
"address": "Endereço",
"network": "Rede",
"destinationPort": "Porta de Destino",
"targetAddress": "Endereço de Destino",
"monitorDesc": "Deixe em branco para ouvir todos os IPs",
"meansNoLimit": "= Ilimitado. (unidade: GB)",
"totalFlow": "Fluxo Total",
"leaveBlankToNeverExpire": "Deixe em branco para nunca expirar",
"certificatePath": "Caminho",
"certificateContent": "Conteúdo",
"publicKey": "Chave Pública",
"privatekey": "Chave Privada",
"client": "Cliente",
"export": "Exportar Todos os URLs",
"clone": "Clonar",
"resetAllTraffic": "Redefinir Tráfego de Todos os Inbounds",
"resetAllTrafficTitle": "Redefinir Tráfego de Todos os Inbounds",
"resetAllTrafficContent": "Tem certeza de que deseja redefinir o tráfego de todos os inbounds?",
"email": "Email",
"IPLimit": "Limite de IP",
"IPLimitlog": "Log de IP",
"IPLimitlogclear": "Limpar o Log",
"setDefaultCert": "Definir Certificado pelo Painel",
"setDefaultCertEmpty": "Nenhum certificado configurado para o painel. Configure um em Configurações primeiro.",
"streamTab": "Transmissão",
"securityTab": "Segurança",
"sniffingTab": "Inspeção",
"sniffingMetadataOnly": "Apenas metadados",
"sniffingRouteOnly": "Apenas roteamento",
"sniffingIpsExcluded": "IPs excluídos",
"sniffingDomainsExcluded": "Domínios excluídos",
"decryption": "Descriptografia",
"encryption": "Criptografia",
"vlessAuthX25519": "X25519 (native)",
"vlessAuthMlkem768": "ML-KEM-768 (native)",
"vlessAuthX25519Xorpub": "X25519 (xorpub)",
"vlessAuthX25519Random": "X25519 (random)",
"vlessAuthMlkem768Xorpub": "ML-KEM-768 (xorpub)",
"vlessAuthMlkem768Random": "ML-KEM-768 (random)",
"vlessAuthCustom": "Personalizado",
"vlessAuthSelected": "Selecionado: {auth}",
"vlessAuthGenerate": "Gerar chaves",
"vlessAuthGenerateButton": "Gerar",
"advanced": {
"title": "Seções JSON do inbound",
"subtitle": "JSON completo do inbound e editores específicos para settings, sniffing e streamSettings.",
"all": "Tudo",
"allHelp": "Objeto inbound completo com todos os campos em um único editor.",
"settings": "Configurações",
"settingsHelp": "Wrapper do bloco settings do Xray:",
"sniffing": "Sniffing",
"sniffingHelp": "Wrapper do bloco sniffing do Xray:",
"stream": "Stream",
"streamHelp": "Wrapper do bloco stream do Xray:"
},
"subSortIndex": "Ordem sub",
"inboundInfo": "Informações do Inbound",
"exportInbound": "Exportar Inbound",
"import": "Importar",
"importInbound": "Importar um Inbound",
"periodicTrafficResetTitle": "Reset de Tráfego",
"periodicTrafficResetDay": "Dia da redefinição mensal",
"periodicTrafficReset": {
"never": "Nunca",
"daily": "Diariamente",
"weekly": "Semanalmente",
"monthly": "Mensalmente",
"hourly": "A cada hora"
},
"toasts": {
"obtain": "Obter",
"updateSuccess": "A atualização foi bem-sucedida",
"logCleanSuccess": "O log foi limpo",
"inboundUpdateSuccess": "Entrada atualizada com sucesso",
"inboundCreateSuccess": "Entrada criada com sucesso",
"bulkDeleted": "{count} inbounds excluídos",
"bulkDeletedMixed": "{ok} excluídos, {failed} com falha",
"clonedMany": "{count} inbounds clonados",
"clonedMixed": "{ok} clonados, {failed} com falha",
"inboundDeleteSuccess": "Entrada excluída com sucesso",
"inboundClientAddSuccess": "Cliente(s) de entrada adicionado(s)",
"inboundClientDeleteSuccess": "Cliente de entrada excluído",
"inboundClientUpdateSuccess": "Cliente de entrada atualizado",
"savedNodeOfflineWillSync": "Salvo localmente. Um nó de apoio está offline ou desativado — a alteração será sincronizada assim que reconectar.",
"resetAllClientTrafficSuccess": "Todo o tráfego do cliente foi reiniciado",
"resetAllTrafficSuccess": "Todo o tráfego foi reiniciado",
"resetInboundClientTrafficSuccess": "O tráfego foi reiniciado",
"resetInboundTrafficSuccess": "O tráfego de entrada foi reiniciado",
"trafficGetError": "Erro ao obter tráfegos",
"getNewX25519CertError": "Erro ao obter o certificado X25519.",
"getNewmldsa65Error": "Erro ao obter o certificado mldsa65.",
"getNewVlessEncError": "Erro ao obter o certificado VlessEnc.",
"scanRealityTargetError": "Falha ao escanear o alvo REALITY.",
"scanRealityTargetFeasible": "O alvo é viável — alvo e SNI preenchidos.",
"scanRealityTargetNotFeasible": "O alvo é acessível, mas não é viável para REALITY.",
"scanRealityTargetPrivate": "O destino funciona, mas está em uma rede privada/local.",
"invalidClientField": "Cliente {client}: campo {field} — {reason}",
"invalidField": "{field} — {reason}",
"moreIssues": "{message} (+{count} mais)"
},
"form": {
"echSockopt": "Sockopt ECH",
"echSockoptTip": "Opções de socket para a conexão que o Xray usa ao buscar a lista de configurações ECH (por exemplo, rotear a consulta por um outbound dialerProxy). Deixe desativado para usar os padrões.",
"curvePreferences": "Preferências de curva",
"curvePreferencesTip": "Restringe as curvas de troca de chaves TLS que o servidor oferece, em ordem de preferência (por exemplo, X25519MLKEM768, X25519). Deixe vazio para usar os padrões do Xray-core.",
"masterKeyLog": "Log da chave mestra",
"masterKeyLogTip": "Caminho para gravar as chaves mestras TLS (formato SSLKEYLOGFILE) para depuração com o Wireshark. Deixe vazio em produção — isso permite que qualquer pessoa com o arquivo descriptografe o tráfego.",
"verifyPeerCertByName": "Verificar certificado do par pelo nome",
"verifyPeerCertByNameTip": "Instrui os clientes a verificar o certificado do servidor em relação a este nome em vez do SNI. Nomes separados por vírgula. Apenas do painel — incluído nos links de compartilhamento (vcn). A substituição moderna para allowInsecure, que o Xray removeu após 2026-06-01.",
"pinFromCert": "Preencher a partir do certificado desta entrada",
"pinFromRemote": "Obter o hash via ping ao SNI (xray tls ping)",
"pinFromRemoteNoSni": "Defina primeiro o SNI (serverName) para fazer o ping no certificado remoto.",
"pinFromRemoteFailed": "Não foi possível obter o hash do certificado remoto.",
"limitFallback": "Limitar fallback",
"limitFallbackUpload": "Limitar upload do fallback",
"limitFallbackDownload": "Limitar download do fallback",
"afterBytes": "Após bytes",
"afterBytesTip": "Permite que o fallback opere em velocidade máxima por esta quantidade de bytes e depois começa a limitar. 0 = limitar a partir do primeiro byte.",
"bytesPerSec": "Bytes por seg",
"bytesPerSecTip": "Limite de velocidade (bytes/seg) aplicado ao tráfego de fallback após o limiar, para que sondagens não usem seu servidor como banda gratuita até o destino. 0 = sem limite (desativa esta direção).",
"burstBytesPerSec": "Bytes por seg em rajada",
"burstBytesPerSecTip": "Margem para rajadas curtas acima da taxa estável (tamanho do token-bucket). Se for menor que Bytes por seg, é elevado para corresponder.",
"moveUp": "Mover para cima",
"moveDown": "Mover para baixo",
"addAll": "Adicionar todos",
"addAllFallbackTooltip": "Adiciona uma linha de fallback para cada entrada elegível ainda não conectada",
"peers": "Peers",
"addPeer": "Adicionar peer",
"keepAlive": "Keep-alive",
"autoSystemRoutesTooltip": "Apenas Windows. CIDRs são adicionados à tabela de roteamento do sistema automaticamente para que o tráfego correspondente passe pelo TUN.",
"autoOutboundsInterface": "Interface de saída automática",
"autoOutboundsInterfaceTooltip": "Interface física para tráfego de saída. Use 'auto' para detecção; auto-habilitado quando Auto system routes está ativo.",
"rewriteAddress": "Reescrever endereço",
"rewritePort": "Reescrever porta",
"allowedNetwork": "Rede permitida",
"followRedirect": "Seguir redirect",
"accounts": "Contas",
"allowTransparent": "Permitir transparente",
"encryptionMethod": "Método de criptografia",
"fakeTlsDomain": "Domínio FakeTLS (SNI)",
"mtprotoSecret": "Segredo",
"mtgDomainFrontingIp": "IP de domain fronting",
"mtgDomainFrontingPort": "Porta de domain fronting",
"mtgDomainFrontingProxyProtocol": "Protocolo PROXY de domain fronting",
"mtgDomainFrontingHint": "Para onde o mtg envia o tráfego que não é do Telegram — por exemplo, seu site falso NGINX. Deixe o IP vazio para usar o domínio FakeTLS via DNS; a porta padrão é 443.",
"mtgProxyProtocolListener": "Aceitar protocolo PROXY (listener)",
"mtgPreferIp": "Preferência de IP",
"mtgDebug": "Log de depuração",
"mtgRouteThroughXray": "Rotear pelo Xray",
"mtgRouteThroughXrayHint": "Envie o tráfego do Telegram deste proxy pelo Xray para que ele siga suas regras de roteamento. O sidecar mtg sai por uma ponte SOCKS loopback com a tag deste inbound; use essa tag na aba Roteamento para regras avançadas.",
"mtgRouteOutbound": "Saída",
"mtgRouteOutboundHint": "Opcional. Force o tráfego do Telegram a sair por esta saída (ou balanceador). Deixe vazio para que suas regras de roteamento decidam.",
"mtgRouteOutboundPlaceholder": "Usar regras de roteamento",
"mtprotoFakeTlsDomainHint": "Domínio FakeTLS padrão usado para gerar o segredo de um novo cliente. Cada cliente pode usar seu próprio domínio.",
"mtgThrottleMaxConnections": "Conexões máximas",
"mtgThrottleMaxConnectionsHint": "Limita conexões simultâneas de todos os usuários com distribuição justa. 0 desativa o limite.",
"mtgAdTagInvalid": "A ad-tag deve ter exatamente 32 caracteres hexadecimais.",
"mtgPublicIpv4": "IPv4 público",
"mtgPublicIpv6": "IPv6 público",
"mtgPublicIpHint": "O endereço público acessível deste servidor, usado pelo proxy intermediário da ad-tag. Deixe em branco para o mtg detectá-lo automaticamente.",
"visionTestseed": "Vision testseed",
"version": "Versão",
"udpIdleTimeout": "UDP idle timeout (s)",
"masquerade": "Masquerade",
"type": "Tipo",
"upstreamUrl": "URL Upstream",
"rewriteHost": "Reescrever Host",
"skipTlsVerify": "Pular verificação TLS",
"directory": "Diretório",
"statusCode": "Código de status",
"body": "Body",
"headers": "Cabeçalhos",
"proxyProtocol": "Proxy Protocol",
"requestVersion": "Versão da requisição",
"requestMethod": "Método da requisição",
"requestPath": "Caminho da requisição",
"requestHeaders": "Cabeçalhos de requisição",
"responseVersion": "Versão da resposta",
"responseStatus": "Status da resposta",
"responseReason": "Motivo da resposta",
"responseHeaders": "Cabeçalhos de resposta",
"heartbeatPeriod": "Período de heartbeat",
"serviceName": "Nome do serviço",
"authority": "Authority",
"multiMode": "Multi Mode",
"maxBufferedUpload": "Máx. upload em buffer",
"maxUploadSize": "Tamanho máx. de upload (Byte)",
"streamUpServer": "Stream-Up Server",
"serverMaxHeaderBytes": "Máx. bytes cabeçalho servidor",
"paddingBytes": "Bytes de Padding",
"uplinkHttpMethod": "Método HTTP Uplink",
"paddingObfsMode": "Modo obfs de Padding",
"paddingKey": "Padding Key",
"paddingHeader": "Padding Header",
"paddingPlacement": "Posição de Padding",
"paddingMethod": "Método de Padding",
"sessionPlacement": "Session Placement",
"sessionKey": "Session Key",
"sessionIDTable": "Tabela de Session ID",
"sessionIDTableHint": "Conjunto de caracteres para gerar session IDs: um nome predefinido (ALPHABET, Base62, hex, number, …) ou uma string ASCII literal. Deixe vazio para o padrão do xray-core.",
"sessionIDLength": "Comprimento do Session ID",
"sessionIDLengthHint": "Comprimento ou intervalo (ex.: 8-16) do session ID gerado. Usado apenas quando uma Tabela de Session ID está definida; o mínimo deve ser maior que 0.",
"sequencePlacement": "Sequence Placement",
"sequenceKey": "Sequence Key",
"uplinkDataPlacement": "Uplink Data Placement",
"uplinkDataKey": "Uplink Data Key",
"noSseHeader": "Sem cabeçalho SSE",
"ttiMs": "TTI (ms)",
"uplinkMbps": "Uplink (MB/s)",
"downlinkMbps": "Downlink (MB/s)",
"cwndMultiplier": "Multiplicador CWND",
"maxSendingWindow": "Máx. janela de envio",
"externalProxy": "Proxy externo",
"forceTls": "Forçar TLS",
"fingerprint": "Fingerprint",
"defaultOption": "Padrão",
"routeMark": "Route Mark",
"tcpKeepAliveInterval": "TCP Keep Alive Interval",
"tcpKeepAliveIdle": "TCP Keep Alive Idle",
"tcpMaxSeg": "TCP Max Seg",
"tcpUserTimeout": "TCP User Timeout",
"tcpWindowClamp": "TCP Window Clamp",
"tcpWindowClampHint": "Deixe 0 para usar o padrão do sistema. Valores diferentes de zero limitam a janela de recepção TCP anunciada; valores como 600 (do exemplo da documentação do Xray) podem derrubar a taxa de transferência em enlaces de alta latência.",
"tcpFastOpen": "TCP Fast Open",
"multipathTcp": "Multipath TCP",
"penetrate": "Penetrate",
"v6Only": "Apenas V6",
"tcpCongestion": "TCP Congestion",
"dialerProxy": "Dialer Proxy",
"trustedXForwardedFor": "X-Forwarded-For confiável",
"trustedXForwardedForHint": "Confie neste cabeçalho de requisição para obter o IP real do cliente (ex.: CF-Connecting-IP atrás do CDN da Cloudflare). Válido apenas nos transportes WebSocket, HTTPUpgrade, XHTTP e gRPC. Deixe vazio para ignorar cabeçalhos encaminhados.",
"proxyProtocolHint": "Aceite o cabeçalho PROXY protocol para obter o IP real do cliente a partir de um túnel/relay L4 upstream (HAProxy, gost, nginx-stream, Xray dokodemo-door) ou Cloudflare Spectrum. O upstream DEVE enviar PROXY protocol. Funciona em TCP, WebSocket, HTTPUpgrade e gRPC; não em mKCP.",
"realClientIp": "IP real do cliente",
"realClientIpHint": "Capture o IP real do visitante quando o tráfego chega a este inbound através de um CDN ou relay, em vez de registrar o endereço do intermediário. Escolha uma predefinição para preencher os campos sockopt correspondentes abaixo. Esses campos nunca são enviados aos clientes nas assinaturas.",
"realClientIpPresetOff": "Desligado / direto",
"realClientIpPresetCloudflare": "Cloudflare CDN",
"realClientIpPresetProxyProtocol": "Relay L4 / Spectrum (PROXY)",
"realClientIpTrustedHeaderTransportWarn": "Trusted X-Forwarded-For é válido apenas em WebSocket, HTTPUpgrade e XHTTP. No transporte atual este cabeçalho é ignorado.",
"realClientIpProxyProtocolTransportWarn": "PROXY protocol não é suportado neste transporte (mKCP). Use TCP/RAW, WebSocket, HTTPUpgrade, gRPC ou XHTTP.",
"addressPortStrategy": "Estratégia endereço+porta",
"tryDelayMs": "Atraso de tentativa (ms)",
"prioritizeIPv6": "Priorizar IPv6",
"interleave": "Interleave",
"maxConcurrentTry": "Máx. tentativas simultâneas",
"customSockopt": "Sockopt personalizado",
"addCustomOption": "Adicionar opção personalizada",
"serverNameIndication": "SNI",
"cipherSuites": "Cipher Suites",
"autoOption": "Auto",
"minMaxVersion": "Versão mín/máx",
"rejectUnknownSni": "Rejeitar SNI desconhecido",
"disableSystemRoot": "Desabilitar System Root",
"sessionResumption": "Retomada de sessão",
"oneTimeLoading": "Carregamento único",
"usageOption": "Opção de uso",
"buildChain": "Construir cadeia",
"echKey": "ECH key",
"echConfig": "Config ECH",
"pinnedPeerCertSha256": "SHA-256 do cert. do par fixado",
"pinnedPeerCertSha256Tip": "Hashes SHA-256 do certificado do par como string hexadecimal (ex. e8e2d3…), separados por vírgula. Apenas no painel — não é gravado na config xray do servidor, mas é incluído nos links de compartilhamento para que clientes possam fixar o certificado.",
"pinnedPeerCertSha256Placeholder": "hash(es) hexadecimal, separados por vírgula",
"getNewEchCert": "Obter novo certificado ECH",
"show": "Mostrar",
"xver": "Xver",
"target": "Alvo",
"maxTimeDiff": "Máx. diferença de tempo (ms)",
"minClientVer": "Mín. versão cliente",
"maxClientVer": "Máx. versão cliente",
"minClientVerHint": "Vazio não significa sem restrição: o Xray-core aplica o mínimo embutido da build do núcleo em uso (26.3.27 nas versões atuais) e rejeita clientes que reportam uma versão mais antiga — incluindo núcleos de terceiros como Mihomo e sing-box. Definir 1.0.0 os aceita, ao custo de admitir impressões digitais TLS desatualizadas.",
"maxClientVerHint": "Vazio significa sem limite superior. Se definido, não deve ser menor que o mínimo efetivo — a versão mínima do cliente ou, se aquele campo estiver vazio, o mínimo embutido do Xray-core — ou todos os clientes serão rejeitados.",
"clientVerInvalid": "A versão do cliente deve ter até três números separados por pontos, cada um 0-255 (ex.: 26.3.27)",
"maxClientVerBelowMin": "A versão máxima do cliente não deve ser menor que a versão mínima",
"shortIds": "Short IDs",
"realityTargetHint": "Obrigatório. Deve incluir uma porta (ex.: example.com:443). Sem porta, o Xray-core não inicia.",
"realityTargetRequired": "O alvo REALITY é obrigatório",
"realityTargetNeedsPort": "O alvo REALITY deve incluir uma porta (ex.: example.com:443)",
"realityTargetInvalidPort": "O alvo REALITY tem uma porta inválida",
"scan": "Escanear",
"findTargets": "Buscar alvos",
"scanModalTitle": "Scanner de alvos REALITY",
"scanModalDesc": "Valide um domínio ou escaneie um intervalo IP / CIDR para descobrir novos alvos REALITY a partir dos certificados. Deixe vazio para testar os candidatos comuns.",
"scanDiscoverPlaceholder": "IP, CIDR ou domínio — deixe vazio para candidatos comuns",
"scanStatus": "Status",
"scanFeasible": "Viável",
"scanNotFeasible": "Inviável",
"scanCurve": "Troca de chaves",
"scanCert": "Certificado",
"scanCertInvalid": "Não confiável",
"scanCertExpiry": "Certificado expira",
"scanSniUsed": "SNI utilizado",
"scanPrivateNote": "Verificado em uma rede privada/local — este endereço não é acessível pela internet.",
"scanPrivateConfirmTitle": "Destino em uma rede local",
"scanPrivateConfirmContent": "\"{target}\" resolve para um endereço privado ou de loopback. A verificação ignorará a proteção SSRF do painel apenas nesta sondagem. Continuar?",
"scanLatency": "Latência",
"scanUse": "Usar",
"scanRescan": "Reescanear",
"spiderX": "SpiderX",
"spiderXHint": "Semente por cliente — o painel deriva dela um caminho spx único para cada cliente; regenere para rotacionar os caminhos de todos",
"getNewCert": "Obter novo certificado",
"mldsa65Seed": "mldsa65 Seed",
"mldsa65Verify": "mldsa65 Verify",
"getNewSeed": "Obter novo Seed",
"listenHelp": "Você também pode informar um caminho de socket Unix (ex.: /run/xray/in.sock), ou um nome de socket abstrato com o prefixo @ (ex.: @xray/in.sock), para escutar em um socket em vez de uma porta TCP — nesse caso, defina a Porta como 0.",
"shareAddrStrategy": "Estratégia de endereço de compartilhamento",
"shareAddrStrategyHelp": "Controla qual endereço é gravado nos links de compartilhamento exportados, códigos QR e na saída de assinatura.",
"shareAddr": "Endereço de compartilhamento personalizado",
"shareAddrHelp": "Usado apenas quando a estratégia de endereço de compartilhamento é Personalizada. Informe um host ou IP sem esquema nem porta.",
"subSortIndex": "Ordem na assinatura",
"subSortIndexHelp": "Posição dos links desta entrada na saída da assinatura (página de assinatura e aplicativos cliente). Valores menores vêm primeiro; valores iguais mantêm a ordem de criação. Não afeta a lista de entradas do painel.",
"disableFlow": "Desativar o flow XTLS",
"disableFlowHelp": "Exclui este inbound da injeção automática de xtls-rprx-vision, mesmo quando o transporte suporta flow (ex.: um inbound XHTTP tunelado com criptografia VLESS). Os clientes mantêm o Vision nos seus outros inbounds compatíveis da mesma assinatura. Somente VLESS.",
"shareAddrStrategyOptions": {
"node": "Endereço do nó",
"listen": "Endereço de escuta do inbound",
"custom": "Personalizada"
}
},
"info": {
"mode": "Modo",
"grpcServiceName": "grpc serviceName",
"grpcMultiMode": "grpc multiMode",
"interfaceName": "Nome da interface",
"mtu": "MTU",
"gateway": "Gateway",
"dns": "DNS",
"outboundsInterface": "Interface de saída",
"autoSystemRoutes": "Rotas do sistema automáticas",
"followRedirect": "FollowRedirect",
"auth": "Auth",
"noKernelTun": "TUN sem kernel",
"keepAlive": "Keep alive",
"peerNumber": "Peer {n}",
"peerNumberConfig": "Config Peer {n}"
},
"sniffingDestOverride": "Substituição de destino"
},
"clients": {
"tabBasics": "Básico",
"tabCredentials": "Credenciais",
"tabLinks": "Links",
"wireguardConfig": "Configuração do WireGuard",
"config": "Configuração",
"linksHint": "Adicione links de terceiros e URLs de assinatura remotas para incluir na assinatura deste cliente.",
"addExternalLink": "Adicionar link externo",
"addExternalSubscription": "Adicionar assinatura externa",
"noExternalLinks": "Ainda não há links externos.",
"noExternalSubscriptions": "Ainda não há assinaturas externas.",
"namePrefix": "Prefixo do nome",
"lastFetchAt": "Última busca",
"lastFetchError": "Erro na busca",
"neverFetched": "Ainda não buscado",
"submitEdit": "Salvar alterações",
"clientCount": "Número de clientes",
"bulk": "Adicionar em lote",
"selectAll": "Selecionar tudo",
"clearAll": "Limpar tudo",
"method": "Método",
"first": "Primeiro",
"last": "Último",
"ipLog": "Registro de IP",
"prefix": "Prefixo",
"postfix": "Sufixo",
"delayedStart": "Iniciar após o primeiro uso",
"expireDays": "Duração (dias)",
"renew": "Renovação automática",
"renewDesc": "Renovação automática após a expiração. (0 = desativar) (unidade: dia)",
"renewDays": "Renovação automática (dias)",
"searchPlaceholder": "Buscar email, comentário, sub ID, UUID, senha, auth, Telegram ID…",
"filterTitle": "Filtrar clientes",
"clearAllFilters": "Limpar tudo",
"filters": {
"nodes": "Nós",
"localPanel": "Local (este painel)"
},
"showingCount": "Mostrando {shown} de {total}",
"sortOldest": "Mais antigos primeiro",
"sortNewest": "Mais novos primeiro",
"sortRecentlyUpdated": "Atualizados recentemente",
"sortRecentlyOnline": "Online recentemente",
"sortEmailAZ": "Email A→Z",
"sortEmailZA": "Email Z→A",
"sortMostTraffic": "Mais tráfego",
"sortHighestRemaining": "Maior restante",
"sortExpiringSoonest": "Expira em breve",
"has": "Tem",
"hasNot": "Não tem",
"actions": "Ações",
"totalGB": "Limite de tráfego (GB)",
"totalGBDesc": "Cota de dados para este cliente. 0 = ilimitado.",
"expiryTime": "Expiração",
"addClients": "Adicionar clientes",
"limitIp": "Limite de IP",
"limitIpDesc": "Máximo de IPs simultâneos. 0 = ilimitado.",
"limitHwid": "Limite de HWID",
"limitHwidDesc": "Máximo de dispositivos registrados para solicitações de assinatura. 0 = ilimitado.",
"hwidLog": "Dispositivos HWID",
"hwidDevice": "Dispositivo registrado",
"noHwids": "Ainda não há dispositivos HWID",
"firstSeen": "Visto primeiro",
"lastSeen": "Visto por último",
"deleteHwid": "Remover dispositivo",
"deleteHwidConfirm": "Remover este dispositivo? Ele precisará se registrar novamente na próxima busca da assinatura.",
"hwidDeleted": "Dispositivo removido.",
"clearHwidsConfirm": "Remover todos os dispositivos registrados? Cada dispositivo precisará se registrar novamente na próxima busca da assinatura.",
"limitIpFail2banMissing": "O Fail2ban não está instalado, portanto o limite de IP não pode ser aplicado. Instale o Fail2ban pelo menu bash do x-ui para ativar esta opção.",
"limitIpFail2banWindows": "O Fail2ban não está disponível no Windows, portanto o limite de IP não pode ser aplicado.",
"limitIpDisabled": "O recurso de limite de IP está desativado neste servidor.",
"password": "Senha",
"passwordDesc": "Usada apenas pelos clientes Trojan e Shadowsocks; ignorada para VLESS, VMess, Hysteria e WireGuard.",
"subId": "ID da assinatura",
"online": "Online",
"email": "Email",
"emailInvalidChars": "O e-mail não pode conter espaços, '/', '\\' ou caracteres de controle",
"subIdInvalidChars": "O ID de assinatura não pode conter espaços, '/', '\\' ou caracteres de controle",
"group": "Grupo",
"groupDesc": "Rótulo lógico para agrupar clientes relacionados (ex.: equipe, cliente, região). Filtrável pela barra de ferramentas.",
"groupPlaceholder": "ex.: customer-a",
"comment": "Comentário",
"traffic": "Tráfego",
"speed": "Velocidade",
"offline": "Offline",
"addClient": "Adicionar cliente",
"qrCode": "Código QR",
"clientInfo": "Informações do cliente",
"editClient": "Editar cliente",
"client": "Cliente",
"enabled": "Habilitado",
"remaining": "Restante",
"duration": "Duração",
"attachedInbounds": "Inbounds associados",
"selectInbound": "Selecione um ou mais inbounds",
"selectAllInbounds": "Selecionar tudo",
"clearAllInbounds": "Limpar tudo",
"noSubId": "Este cliente não tem subId, sem link compartilhável.",
"noLinks": "Sem links compartilháveis — associe primeiro este cliente a um inbound compatível com o protocolo.",
"link": "Link",
"resetNotPossible": "Associe primeiro este cliente a um inbound.",
"resetAllTraffics": "Redefinir o tráfego de todos os clientes",
"resetAllTrafficsTitle": "Redefinir o tráfego de todos os clientes?",
"resetAllTrafficsContent": "Os contadores de envio/recebimento de cada cliente vão a zero. Cota e expiração não são afetadas. Não é possível desfazer.",
"deleteConfirmTitle": "Excluir o cliente {email}?",
"deleteConfirmContent": "Isto remove o cliente de cada inbound associado e descarta o registro de tráfego. Não é possível desfazer.",
"adjustSelected": "Ajustar ({count})",
"subLinksSelected": "Links sub ({count})",
"addToGroupTitle": "Adicionar {count} cliente(s) a um grupo",
"addToGroupTooltip": "Escolha um grupo existente ou digite um novo nome. Use Ungroup para remover clientes do grupo atual.",
"groupName": "Nome do grupo",
"addToGroupSuccessToast": "{count} cliente(s) adicionado(s) a {group}",
"ungroupSuccessToast": "Grupo limpo de {count} cliente(s)",
"ungroup": "Desagrupar",
"ungroupConfirmTitle": "Remover {count} cliente(s) do grupo?",
"ungroupConfirmContent": "Limpa o rótulo de grupo de cada cliente selecionado. Os clientes em si são mantidos (use Delete para remover completamente).",
"addToGroup": "Adicionar ao grupo",
"attach": "Associar",
"adjust": "Ajustar",
"subLinks": "Links de assinatura",
"enable": "Ativar",
"disable": "Desativar",
"bulkEnableConfirmTitle": "Ativar {count} clientes?",
"bulkEnableConfirmContent": "Ativa cada cliente selecionado em todos os inbounds associados. Clientes cuja cota se esgotou ou cuja validade expirou serão desativados novamente de forma automática.",
"bulkDisableConfirmTitle": "Desativar {count} clientes?",
"bulkDisableConfirmContent": "Desativa cada cliente selecionado em todos os inbounds associados. Eles perdem o acesso imediatamente, mas seus registros e tráfego são mantidos.",
"selectedCount": "{count} selecionado(s)",
"attachToInboundsTitle": "Associar {count} cliente(s) a entrada(s)",
"attachToInboundsDesc": "Associa os {count} cliente(s) selecionados (mesmo UUID/senha e tráfego compartilhado) às entradas escolhidas. Mantêm suas associações existentes.",
"attachToInboundsTargets": "Entradas de destino",
"attachToInboundsNoTargets": "Não há entradas multiusuário disponíveis para associação.",
"detach": "Desassociar",
"detachFromInboundsTitle": "Desassociar {count} cliente(s) de entrada(s)",
"detachFromInboundsDesc": "Remove os {count} cliente(s) selecionados das entradas escolhidas. Pares onde o cliente não estava associado são ignorados silenciosamente. Os registros dos clientes são mantidos (use Delete para remover completamente).",
"detachFromInboundsTargets": "Entradas para desassociar",
"detachFromInboundsNoTargets": "Não há entradas multiusuário disponíveis.",
"detachFromInboundsResult": "Desassociados {detached}, ignorados {skipped}.",
"detachFromInboundsResultMixed": "Desassociados {detached}, ignorados {skipped}, erros {errors}.",
"subLinksTitle": "Links sub ({count})",
"subLinkColumn": "URL da assinatura",
"subJsonLinkColumn": "URL JSON da assinatura",
"subLinksCopyAll": "Copiar tudo",
"subLinksCopiedAll": "Copiados {count} link(s)",
"subLinksEmpty": "Nenhum dos clientes selecionados tem ID de assinatura.",
"subLinksDisabled": "O serviço de assinatura está desabilitado.",
"subLinksDisabledHint": "Habilite a assinatura em Configurações do Painel → Assinatura para gerar links.",
"bulkDeleteConfirmTitle": "Excluir {count} clientes?",
"bulkDeleteConfirmContent": "Cada cliente selecionado é removido dos inbounds associados e o registro de tráfego é descartado. Não é possível desfazer.",
"bulkAdjustTitle": "Ajustar {count} clientes",
"bulkAdjustHint": "Valores positivos estendem, negativos reduzem. Clientes com expiração ou tráfego ilimitado são ignorados para esse campo.",
"bulkAdjustNothing": "Defina dias ou tráfego antes de aplicar.",
"addDays": "Adicionar dias",
"addTrafficGB": "Adicionar tráfego (GB)",
"bulkFlow": "Definir flow",
"bulkFlowNoChange": "Sem alteração",
"bulkFlowDisable": "Desativar (limpar flow)",
"delDepleted": "Excluir esgotados",
"delDepletedConfirmTitle": "Excluir clientes esgotados?",
"delDepletedConfirmContent": "Remove todos os clientes cuja cota de tráfego foi esgotada ou cuja expiração já passou. Não é possível desfazer.",
"exportClients": "Exportar clientes",
"importClients": "Importar clientes",
"import": "Importar",
"delOrphans": "Excluir clientes sem inbound",
"delOrphansConfirmTitle": "Excluir clientes sem inbound?",
"delOrphansConfirmContent": "Remove todos os clientes que não estão vinculados a nenhum inbound, junto com seu registro de tráfego. Não é possível desfazer.",
"auth": "Auth",
"hysteriaAuth": "Hysteria Auth",
"hysteriaAuthDesc": "Credencial usada apenas pelos clientes Hysteria. Trojan e Shadowsocks usam o campo \"Senha\" em vez disso.",
"uuid": "UUID",
"flow": "Flow",
"vmessSecurity": "Segurança VMess",
"wireguardPrivateKey": "Chave privada do WireGuard",
"wireguardPublicKey": "Chave pública do WireGuard",
"wireguardPreSharedKey": "Chave pré-compartilhada do WireGuard",
"wireguardAllowedIPs": "IPs permitidos do WireGuard",
"wireguardAllowedIPsHint": "Deixe vazio para atribuir automaticamente; separe as entradas com vírgulas",
"amneziaWgPrivateKey": "Chave privada do AmneziaWG",
"amneziaWgPublicKey": "Chave pública do AmneziaWG",
"amneziaWgPreSharedKey": "Chave pré-compartilhada do AmneziaWG",
"amneziaWgAllowedIPs": "IPs permitidos do AmneziaWG",
"amneziaWgAllowedIPsHint": "Deixe vazio para atribuir automaticamente; separe as entradas com vírgulas",
"amneziaWgForwardedPorts": "Portas encaminhadas",
"amneziaWgForwardedPortsHint": "Portas/intervalos redirecionados (DNAT) para este cliente, ex. 80, 443, 8000-8100. Deixe vazio se não aplicável.",
"amneziaWgConfig": "Configuração do AmneziaWG",
"mtprotoSecret": "Segredo MTProto",
"mtprotoSecretHint": "O segredo FakeTLS do cliente. Gere novamente para trocá-lo.",
"mtprotoAdTag": "Ad-tag (canal patrocinado)",
"mtprotoAdTagHint": "Tag hexadecimal opcional de 32 caracteres do registro de proxy do Telegram. Quando definida, este cliente é roteado pelos proxies intermediários do Telegram e um canal patrocinado aparece no topo da lista de conversas.",
"reverseTag": "Tag reversa",
"reverseTagPlaceholder": "Reverse tag opcional",
"telegramId": "ID de usuário do Telegram",
"telegramIdPlaceholder": "ID numérico de usuário do Telegram (0 = nenhum)",
"ipLimit": "Limite de IP",
"toasts": {
"deleted": "Cliente excluído",
"trafficReset": "Tráfego redefinido",
"allTrafficsReset": "Tráfego de todos os clientes redefinido",
"bulkDeleted": "{count} clientes excluídos",
"bulkDeletedMixed": "{ok} excluídos, {failed} com falha",
"bulkEnabled": "{count} clientes ativados",
"bulkEnabledMixed": "{ok} ativados, {failed} com falha",
"bulkDisabled": "{count} clientes desativados",
"bulkDisabledMixed": "{ok} desativados, {failed} com falha",
"bulkCreated": "{count} clientes criados",
"bulkCreatedMixed": "{ok} criados, {failed} com falha",
"bulkAdjusted": "{count} clientes ajustados",
"bulkAdjustedMixed": "{ok} ajustados, {skipped} ignorados",
"delDepleted": "{count} clientes esgotados excluídos",
"delOrphans": "{count} clientes sem inbound excluídos",
"imported": "{count} clientes importados",
"importedMixed": "{ok} importados, {failed} ignorados"
},
"renewMax": "Renovações máximas",
"renewMaxDesc": "Quantas vezes a renovação automática pode ocorrer antes de o cliente ser deixado a expirar. 0 significa sem limite. Recuperar vários períodos perdidos consome uma renovação por período.",
"renewOnDay": "Renovar no dia",
"renewOnDayDesc": "Renova neste dia de cada mês do calendário, à meia-noite no fuso horário do painel, em vez de a cada N dias. Se o mês for curto demais para o dia escolhido, renova no último dia dele. 0 mantém o modo de intervalo em dias.",
"renewsUsed": "Renovações usadas"
},
"groups": {
"name": "Nome",
"clientCount": "Clientes",
"totalGroups": "Total de grupos",
"totalGroupedClients": "Clientes com grupo",
"trafficUsed": "Tráfego usado",
"upload": "Envio",
"download": "Recebimento",
"totalTraffic": "Tráfego total",
"totalUpDown": "Total de envio / recebimento",
"addGroup": "Adicionar grupo",
"createSuccess": "Grupo «{name}» criado.",
"rename": "Renomear",
"renameTitle": "Renomear {name}",
"renameCollision": "Já existe um grupo chamado «{name}».",
"renameSuccess": "Grupo renomeado em {count} cliente(s).",
"deleteConfirmTitle": "Excluir o grupo {name}?",
"deleteConfirmContent": "Isso remove o grupo e limpa seu rótulo de {count} cliente(s). Os clientes em si não são excluídos.",
"deleteSuccess": "Grupo limpo de {count} cliente(s).",
"resetTraffic": "Redefinir tráfego",
"resetConfirmTitle": "Redefinir tráfego do grupo {name}?",
"resetConfirmContent": "Isso redefine apenas o contador de tráfego do grupo. Os contadores de cada cliente não são afetados.",
"resetSuccess": "Tráfego do grupo {name} redefinido.",
"adjustSuccess": "Ajustados {count} cliente(s) em {name}.",
"emptyForAction": "Este grupo ainda não tem clientes.",
"deleteGroupOnly": "Excluir grupo (manter clientes)",
"deleteClients": "Excluir clientes do grupo",
"deleteClientsConfirmTitle": "Excluir todos os clientes em {name}?",
"deleteClientsConfirmContent": "Isso remove permanentemente {count} cliente(s) junto com seus registros de tráfego. O rótulo de grupo também é limpo. Isso não pode ser desfeito.",
"deleteClientsSuccess": "Excluídos {count} cliente(s).",
"deleteClientsMixed": "{ok} excluídos, {failed} ignorados",
"addToGroup": "Adicionar clientes…",
"addToGroupTitle": "Adicionar clientes ao grupo «{name}»",
"addToGroupDesc": "Selecione clientes para adicionar a este grupo. Mantêm suas associações de entrada atuais; apenas o rótulo de grupo muda. Clientes já neste grupo não são listados.",
"addToGroupEmpty": "Não há outros clientes disponíveis para adicionar.",
"addToGroupResult": "Adicionados {count} cliente(s) a {name}.",
"removeFromGroup": "Remover clientes…",
"removeFromGroupTitle": "Remover clientes do grupo «{name}»",
"removeFromGroupDesc": "Selecione membros para remover deste grupo. Os clientes em si são mantidos (use «Excluir clientes do grupo» para removê-los por completo).",
"removeFromGroupResult": "Removidos {count} cliente(s) de {name}."
},
"nodes": {
"addNode": "Adicionar nó",
"editNode": "Editar nó",
"totalNodes": "Total de nós",
"onlineNodes": "Online",
"offlineNodes": "Offline",
"avgLatency": "Latência média",
"name": "Nome",
"namePlaceholder": "ex.: de-frankfurt-1",
"addressPlaceholder": "panel.example.com ou 1.2.3.4",
"remark": "Observação",
"scheme": "Esquema",
"address": "Endereço",
"port": "Porta",
"basePath": "Caminho base",
"apiToken": "Token API",
"apiTokenPlaceholder": "Token da página de Configurações do painel remoto",
"apiTokenHint": "O painel remoto exibe o token da API em Autenticação → Token da API.",
"apiTokenKeepHint": "Deixe em branco para manter o token atual",
"allowPrivateAddress": "Permitir endereço privado",
"allowPrivateAddressHint": "Ativar apenas para nós em uma rede privada ou VPN.",
"outboundTag": "Outbound de conexão",
"outboundTagHint": "Roteie o tráfego da API do painel deste nó pelo outbound Xray selecionado. Um inbound de ponte loopback é adicionado automaticamente à configuração em execução e aplicado ao vivo. Deixe em branco para uma conexão direta.",
"outboundTagPlaceholder": "Conexão direta",
"inboundSyncMode": "Importação de inbounds",
"inboundSyncModeHint": "Escolha quais inbounds importar deste nó. Nós existentes importam todos por padrão.",
"allInbounds": "Todos os inbounds",
"selectedInbounds": "Inbounds selecionados",
"inboundTags": "Inbounds",
"inboundTagsHint": "A seleção é comparada pela tag do inbound. Uma seleção vazia não importa nenhum.",
"inboundTagsPlaceholder": "Carregue e selecione inbounds",
"loadInbounds": "Carregar inbounds do nó",
"inboundsLoaded": "{{count}} inbounds carregados",
"inboundsLoadFailed": "Falha ao carregar inbounds",
"enable": "Ativado",
"status": "Status",
"cpu": "CPU",
"mem": "Memória",
"netUp": "Subida de rede (KB/s)",
"netDown": "Descida de rede (KB/s)",
"uptime": "Tempo ativo",
"latency": "Latência",
"lastHeartbeat": "Último heartbeat",
"xrayVersion": "Versão do Xray",
"panelVersion": "Versão do painel",
"actions": "Ações",
"probe": "Sondar agora",
"updatePanel": "Atualizar painel",
"updateSelected": "Atualizar selecionados ({count})",
"updateAvailable": "Atualização disponível",
"updateConfirmTitle": "Atualizar {count} nó(s) para a versão mais recente?",
"updateConfirmContent": "Cada nó selecionado baixa a versão mais recente e reinicia nela. Apenas nós ativos e online são atualizados.",
"updateDevChannel": "Atualizar para o canal de desenvolvimento (último commit)",
"testConnection": "Testar conexão",
"connectionOk": "Conexão OK ({ms} ms)",
"connectionFailed": "Falha na conexão",
"never": "nunca",
"justNow": "agora mesmo",
"subNode": "Subnó",
"subNodeTip": "Somente leitura: um nó descendente acessado através de {parent}. Gerencie-o pelo próprio painel de {parent}.",
"deleteConfirmTitle": "Excluir o nó \"{name}\"?",
"deleteConfirmContent": "Isso interrompe o monitoramento do nó. O painel remoto em si não é afetado.",
"statusValues": {
"online": "Online",
"offline": "Offline",
"unknown": "Desconhecido",
"xrayError": "Erro do Xray",
"xrayStopped": "Parado"
},
"toasts": {
"list": "Falha ao carregar os nós",
"obtain": "Falha ao carregar o nó",
"add": "Adicionar nó",
"update": "Atualizar nó",
"delete": "Excluir nó",
"deleted": "Nó excluído",
"test": "Testar conexão",
"fillRequired": "Nome, endereço, porta e token da API são obrigatórios",
"probeFailed": "Falha na sondagem",
"updateStarted": "Atualização do painel iniciada",
"updateResult": "Atualização iniciada em {ok} nó(s), {failed} falharam",
"updateNoneEligible": "Selecione pelo menos um nó online e ativo",
"saveMtls": "Salvar mTLS do nó",
"reloadMtls": "Reload master mTLS credential"
},
"tlsVerifyMode": "Verificação TLS",
"tlsVerifyModeHint": "Como o painel valida o certificado HTTPS do nó. Fixar ou Ignorar são para certificados autoassinados (apenas nós https).",
"tlsVerify": "Verificar (CA padrão)",
"tlsPin": "Fixar certificado (SHA-256)",
"tlsSkip": "Ignorar verificação",
"tlsMtls": "TLS mútuo (certificado de cliente)",
"mtlsFormHint": "Este nó autentica o painel com um certificado de cliente. Copie o CA deste painel na seção mTLS do nó para o nó, defina o CA confiável dele e reinicie-o.",
"mtls": {
"title": "mTLS do nó",
"intro": "O TLS mútuo adiciona um fator de certificado de cliente além do token de API nas chamadas entre nós. É opcional: deixe vazio para manter apenas a autenticação por token.",
"copyCa": "Copiar o CA deste painel",
"copyCaHint": "Entregue este CA aos nós gerenciados por este painel e defina a verificação TLS deles como TLS mútuo.",
"caCopied": "Certificado CA copiado para a área de transferência",
"caFailed": "Falha ao obter o certificado CA",
"trustLabel": "CA confiável (painel superior)",
"trustHint": "Quando este painel também é um nó, cole aqui o CA do painel que o gerencia para exigir seu certificado de cliente. Reinicie o painel para aplicar.",
"trustPlaceholder": "-----BEGIN CERTIFICATE-----",
"save": "Salvar CA confiável",
"saved": "CA confiável salvo — reinicie o painel para aplicar"
},
"tlsSkipWarning": "Ignorar a verificação remove a proteção contra ataques man-in-the-middle — o token de API pode ser interceptado. Prefira fixar o certificado.",
"pinnedCert": "SHA-256 do certificado fixado",
"pinnedCertHint": "SHA-256 do certificado do nó em base64 ou hex. Use Obter para lê-lo do nó agora.",
"pinnedCertPlaceholder": "SHA-256 em base64 ou hex",
"fetchPin": "Obter",
"pinFetched": "Certificado atual do nó obtido",
"pinFetchFailed": "Não foi possível obter o certificado"
},
"settings": {
"defaultTag": "Padrão",
"title": "Configurações do Painel",
"save": "Salvar",
"infoDesc": "Toda alteração feita aqui precisa ser salva. Reinicie o painel para aplicar as alterações.",
"restartPanel": "Reiniciar painel",
"restartPanelDesc": "Tem certeza de que deseja reiniciar o painel? Se não conseguir acessar o painel após reiniciar, consulte os logs do painel no servidor.",
"restartPanelSuccess": "O painel foi reiniciado com sucesso",
"actions": "Ações",
"resetDefaultConfig": "Redefinir para Padrão",
"panelSettings": "Geral",
"securitySettings": "Autenticação",
"securityWarnings": "Avisos de segurança",
"panelExposed": "Seu painel pode estar exposto:",
"warnHttp": "O painel é servido por HTTP simples — configure TLS para produção.",
"warnDefaultPort": "A porta padrão 2053 é bem conhecida — altere para uma porta aleatória.",
"warnDefaultBasePath": "O caminho base padrão \"/\" é bem conhecido — altere para um caminho aleatório.",
"warnDefaultSubPath": "O caminho de assinatura padrão \"/sub/\" é bem conhecido — altere-o.",
"warnDefaultJsonPath": "O caminho de assinatura JSON padrão \"/json/\" é bem conhecido — altere-o.",
"TGBotSettings": "Bot do Telegram",
"panelListeningIP": "IP de Escuta",
"panelListeningIPDesc": "O endereço IP para o painel web. (deixe em branco para escutar em todos os IPs)",
"panelListeningDomain": "Domínio de Escuta",
"panelListeningDomainDesc": "O nome de domínio para o painel web. (deixe em branco para escutar em todos os domínios e IPs)",
"panelPort": "Porta de Escuta",
"panelPortDesc": "O número da porta para o painel web. (deve ser uma porta não usada)",
"publicKeyPath": "Caminho da Chave Pública",
"publicKeyPathDesc": "O caminho do arquivo de chave pública para o painel web. (começa com ‘/‘)",
"privateKeyPath": "Caminho da Chave Privada",
"privateKeyPathDesc": "O caminho do arquivo de chave privada para o painel web. (começa com ‘/‘)",
"panelUrlPath": "Caminho URI",
"panelUrlPathDesc": "O caminho URI para o painel web. (começa com ‘/‘ e termina com ‘/‘)",
"pageSize": "Tamanho da Paginação",
"pageSizeDesc": "Definir o tamanho da página para a tabela de entradas. (0 = desativado)",
"panelOutbound": "Saída do tráfego do painel",
"panelOutboundDesc": "Encaminha as requisições do próprio painel — verificações de versão e downloads do painel/Xray, Telegram e a atualização normal de arquivos geo — por esta saída do Xray para contornar a filtragem de GitHub/Telegram no servidor. Uma entrada ponte local é adicionada automaticamente à configuração em execução e aplicada ao vivo. A Atualização Automática de Geodata nativa do Xray não é afetada; ela tem sua própria saída de download. Deixe vazio para conexão direta.",
"panelOutboundPh": "Conexão direta",
"datepicker": "Tipo de Calendário",
"datepickerPlaceholder": "Selecionar data",
"datepickerDescription": "Tarefas agendadas serão executadas com base neste calendário.",
"oldUsername": "Nome de Usuário Atual",
"currentPassword": "Senha Atual",
"newUsername": "Novo Nome de Usuário",
"newPassword": "Nova Senha",
"telegramBotEnable": "Ativar Bot do Telegram",
"telegramBotEnableDesc": "Ativa o bot do Telegram.",
"telegramToken": "Token do Telegram",
"telegramTokenDesc": "O token do bot do Telegram obtido de '{'@'}BotFather'.",
"telegramProxy": "Proxy SOCKS",
"telegramProxyDesc": "Ativa o proxy SOCKS5 para conectar ao Telegram. (ajuste as configurações conforme o guia)",
"telegramAPIServer": "Servidor API do Telegram",
"telegramAPIServerDesc": "O servidor API do Telegram a ser usado. Deixe em branco para usar o servidor padrão.",
"telegramChatId": "ID de Chat do Administrador",
"telegramChatIdDesc": "O(s) ID(s) de Chat do Administrador no Telegram. (separado por vírgulas)(obtenha aqui {'@'}userinfobot) ou (use o comando '/id' no bot)",
"telegramNotifyTime": "Hora da Notificação",
"telegramNotifyTimeDesc": "Com que frequência o bot do Telegram envia relatórios periódicos. Escolha um intervalo predefinido ou selecione Personalizado para inserir uma expressão crontab.",
"notifyTime": {
"every": "@every — repetir em um intervalo",
"hourly": "@hourly — a cada hora",
"daily": "@daily — todos os dias às 00:00",
"weekly": "@weekly — toda semana",
"monthly": "@monthly — todo mês",
"custom": "Personalizado (crontab)",
"seconds": "Segundos",
"minutes": "Minutos",
"hours": "Horas",
"interval": "Intervalo",
"unit": "Unidade"
},
"tgNotifyBackup": "Backup do Banco de Dados",
"tgNotifyBackupDesc": "Enviar arquivo de backup do banco de dados junto com o relatório.",
"tgNotifyLogin": "Notificação de Login",
"tgNotifyLoginDesc": "Receba notificações sobre o nome de usuário, endereço IP e horário sempre que alguém tentar fazer login no seu painel web.",
"sessionMaxAge": "Duração da Sessão",
"sessionMaxAgeDesc": "A duração pela qual você pode permanecer logado. (unidade: minuto)",
"expireTimeDiff": "Notificação de Expiração",
"expireTimeDiffDesc": "Receba notificações sobre a data de expiração ao atingir esse limite. (unidade: dia)",
"trafficDiff": "Notificação de Limite de Tráfego",
"trafficDiffDesc": "Receba notificações sobre o limite de tráfego ao atingir esse limite. (unidade: GB)",
"tgNotifyCpu": "Notificação de Carga da CPU",
"tgNotifyCpuDesc": "Receba notificações se a carga da CPU ultrapassar esse limite. (unidade: %)",
"timeZone": "Fuso Horário",
"timeZoneDesc": "As tarefas agendadas serão executadas com base nesse fuso horário.",
"subSettings": "Assinatura",
"subEnable": "Ativar Serviço de Assinatura",
"subEnableDesc": "Ativa o serviço de assinatura.",
"subJsonEnable": "Ativar/Desativar o endpoint de assinatura JSON de forma independente.",
"subJsonEnableTitle": "Assinatura JSON",
"subClashEnableTitle": "Assinatura Clash / Mihomo",
"subFormatsTipTitle": "Configurações de assinatura específicas por formato",
"subFormatsTipDesc": "Configure separadamente os caminhos de URL, URLs reversas e a detecção automática de clientes para JSON e Clash / Mihomo.",
"subFormatsTipAction": "Abrir formatos de assinatura",
"subJsonAutoDetect": "Detectar clientes Xray JSON automaticamente",
"subJsonAutoDetectDesc": "Quando ativado, clientes compatíveis reconhecidos que solicitarem a URL de assinatura padrão receberão automaticamente uma matriz de configurações Xray JSON. Os outros clientes manterão a resposta bruta/Base64. Requer a assinatura JSON ativada e a reinicialização do painel.",
"subJsonAlwaysArray": "Sempre retornar uma matriz JSON",
"subJsonAlwaysArrayDesc": "Retorna o endpoint JSON explícito como matriz mesmo com apenas um perfil, conforme o padrão XTLS. Respostas JSON detectadas automaticamente sempre usam matrizes. Desative para preservar a resposta legada de objeto único.",
"subJsonUserAgentRegex": "Expressão User-Agent do Xray JSON",
"subJsonUserAgentRegexDesc": "Expressão regular Go RE2 comparada com o User-Agent do cliente para selecionar automaticamente o formato Xray JSON na URL de assinatura padrão. Vazia por padrão, então a detecção automática permanece desativada até você definir um padrão para os clientes que deseja atender. Os outros clientes mantêm a resposta bruta/Base64. Reinicie o painel após alterá-la.",
"subClashAutoDetect": "Detectar clientes Clash/Mihomo automaticamente",
"subClashAutoDetectDesc": "Quando ativado, clientes Clash/Mihomo reconhecidos que solicitarem a URL de assinatura padrão receberão automaticamente YAML do Clash. Os navegadores continuarão exibindo a página de assinatura, os outros clientes manterão a resposta bruta/Base64 e as URLs explícitas de JSON e Clash continuarão disponíveis. Requer a assinatura Clash/Mihomo ativada e a reinicialização do painel para aplicar a alteração.",
"subClashUserAgentRegex": "Expressão User-Agent do Clash/Mihomo",
"subClashUserAgentRegexDesc": "Expressão regular Go RE2 comparada com o User-Agent do cliente para reconhecer clientes Clash/Mihomo na URL de assinatura padrão. Deixe em branco para usar o padrão predefinido. Reinicie o painel após alterá-la.",
"subTitle": "Título da Assinatura",
"subTitleDesc": "Título exibido no cliente VPN. Suporta tokens de identidade do cliente: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subSupportUrl": "URL de Suporte",
"subSupportUrlDesc": "Link de suporte técnico exibido no cliente VPN. Suporta tokens de identidade do cliente: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subProfileUrl": "URL de Perfil",
"subProfileUrlDesc": "Um link para o seu site exibido no cliente VPN. Suporta tokens de identidade do cliente: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subAnnounce": "Anúncio",
"subAnnounceDesc": "O texto do anúncio exibido no cliente VPN. Suporta tokens de identidade do cliente: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subThemeDir": "Diretório do tema de assinatura",
"subThemeDirDesc": "Caminho absoluto para uma pasta contendo um modelo personalizado (index.html/sub.html) para a página de assinatura (ex.: /etc/3x-ui/sub_templates/my-theme/). Deixe vazio para usar a página padrão.",
"subThemeDirDocs": "Guia de modelos ↗",
"subEnableRouting": "Ativar roteamento",
"subEnableRoutingDesc": "Configuração global para habilitar o roteamento no cliente VPN. (Apenas para Happ)",
"subRoutingRules": "Regras de roteamento",
"subRoutingRulesDesc": "Cole um deeplink happ:// pronto ou uma URL HTTPS permanente. O painel atualiza as regras remotas em segundo plano e mantém o último valor válido, sem atrasar as solicitações de assinatura. (Apenas para Happ)",
"subHideSettings": "Ocultar configurações do servidor",
"subHideSettingsDesc": "Ocultar a capacidade de visualizar e editar as configurações do servidor no cliente VPN. (Apenas para Happ)",
"subIncyEnableRouting": "Ativar roteamento",
"subIncyEnableRoutingDesc": "Injetar um perfil de roteamento no corpo da assinatura para o cliente Incy. (Apenas para Incy)",
"subIncyRoutingRules": "Regras de roteamento",
"subIncyRoutingRulesDesc": "Cole um deeplink incy:// pronto ou uma URL HTTPS permanente para JSON. O Incy cria um perfil de autorouting e o atualiza automaticamente. (Apenas para Incy)",
"subClashEnableRouting": "Ativar roteamento",
"subClashEnableRoutingDesc": "Incluir regras globais de roteamento Clash/Mihomo nas assinaturas YAML geradas.",
"subClashRoutingRules": "Regras globais de roteamento",
"subClashRoutingRulesDesc": "Cole regras/YAML ou uma URL HTTPS permanente. O painel a atualiza em segundo plano, importa apenas grupos, provedores de regras e regras, e preserva os nós VPN gerados e o último valor válido.",
"subListen": "IP de Escuta",
"subListenDesc": "O endereço IP para o serviço de assinatura. (deixe em branco para escutar em todos os IPs)",
"subPort": "Porta de Escuta",
"subPortDesc": "O número da porta para o serviço de assinatura. (deve ser uma porta não usada). Também é usada para construir o link/QR de assinatura exibido no painel quando \"URI de Proxy Reverso\" abaixo estiver vazio — se a assinatura for acessada por um proxy reverso em outra porta, configure \"URI de Proxy Reverso\" em vez disso.",
"subCertPath": "Caminho da Chave Pública",
"subCertPathDesc": "O caminho do arquivo de chave pública para o serviço de assinatura. (começa com ‘/‘)",
"subKeyPath": "Caminho da Chave Privada",
"subKeyPathDesc": "O caminho do arquivo de chave privada para o serviço de assinatura. (começa com ‘/‘)",
"subPath": "Caminho URI",
"subPathDesc": "O caminho URI para o serviço de assinatura. (começa com ‘/‘ e termina com ‘/‘)",
"subDomain": "Domínio de Escuta",
"subDomainDesc": "O nome de domínio para o serviço de assinatura. (deixe em branco para escutar em todos os domínios e IPs). Também é usado como domínio de fallback para o link de assinatura exibido quando \"URI de Proxy Reverso\" estiver vazio — configure \"URI de Proxy Reverso\" se o painel e a assinatura forem acessados por domínios diferentes (por exemplo, atrás de um proxy reverso).",
"subUpdates": "Intervalos de Atualização",
"subUpdatesDesc": "Os intervalos de atualização da URL de assinatura nos aplicativos de cliente. (unidade: hora)",
"subEncrypt": "Codificar",
"subEncryptDesc": "O conteúdo retornado pelo serviço de assinatura será codificado em Base64.",
"subURI": "URI de Proxy Reverso",
"subURIDesc": "A URL base completa (scheme://dominio[:porta]/caminho/) para o link de assinatura e o código QR, usada em vez de Domínio/Porta de Escuta. Configure isso sempre que a assinatura for acessada por um proxy reverso ou um domínio/porta diferente dos acima.",
"externalTrafficInformEnable": "Informações de tráfego externo",
"externalTrafficInformEnableDesc": "Informar API externa a cada atualização de tráfego.",
"externalTrafficInformURI": "URI de informação de tráfego externo",
"externalTrafficInformURIDesc": "As atualizações de tráfego são enviadas para este URI.",
"restartXrayOnClientDisable": "Reiniciar Xray Após Desativação Automática",
"restartXrayOnClientDisableDesc": "Quando um cliente for desativado automaticamente por expiração ou limite de tráfego, reinicie o Xray.",
"fragment": "Fragmentação",
"fragmentDesc": "Ativa a fragmentação para o pacote TLS hello.",
"fragmentSett": "Configurações de Fragmentação",
"noisesDesc": "Ativar Noises.",
"noisesSett": "Configurações de Noises",
"trustedProxyCidrs": "CIDRs de proxy confiável",
"trustedProxyCidrsDesc": "IPs/CIDRs separados por vírgula que podem definir os cabeçalhos host, proto e IP do cliente encaminhados.",
"ldap": {
"enable": "Habilitar sincronização LDAP",
"host": "Host LDAP",
"port": "Porta LDAP",
"useTls": "Usar TLS (LDAPS)",
"skipTlsVerify": "Pular verificação de certificado TLS",
"skipTlsVerifyDesc": "Inseguro — desativa a validação do certificado do servidor. Use apenas com CAs internos/não confiáveis.",
"bindDn": "Bind DN",
"passwordConfigured": "Configurada; deixe em branco para manter a senha atual.",
"passwordUnconfigured": "Não configurada.",
"passwordPlaceholder": "Configurada — digite um novo valor para substituir",
"baseDn": "Base DN",
"userFilter": "Filtro de usuário",
"userAttr": "Atributo de usuário (username/email)",
"vlessField": "Atributo flag VLESS",
"flagField": "Atributo flag genérico (opcional)",
"flagFieldDesc": "Se definido, sobrescreve o flag VLESS — ex. shadowInactive.",
"truthyValues": "Valores truthy",
"truthyValuesDesc": "Separados por vírgula; padrão: true,1,yes,on",
"invertFlag": "Inverter flag",
"invertFlagDesc": "Habilite quando o atributo significar «desabilitado» (ex. shadowInactive).",
"syncSchedule": "Agendamento da sincronização",
"syncScheduleDesc": "String tipo cron, ex. @every 1m",
"inboundTags": "Tags de entradas",
"inboundTagsDesc": "Entradas nas quais a sincronização LDAP pode auto-criar ou auto-excluir clientes.",
"noInbounds": "Nenhuma entrada encontrada. Crie uma em Entradas primeiro.",
"autoCreate": "Criar clientes automaticamente",
"autoDelete": "Excluir clientes automaticamente",
"defaultTotalGb": "Total padrão (GB)",
"defaultExpiryDays": "Expiração padrão (dias)",
"defaultIpLimit": "Limite de IP padrão"
},
"subFormats": {
"finalMask": "Final Mask",
"finalMaskDesc": "Injeta máscaras TCP/UDP do finalmask do Xray e parâmetros QUIC em cada perfil Xray JSON gerado. Requer um aplicativo compatível com assinaturas Xray JSON e um núcleo Xray recente.",
"packets": "Pacotes",
"length": "Comprimento",
"interval": "Intervalo",
"maxSplit": "Máx. divisão",
"noises": "Ruídos",
"noiseItem": "Ruído №{n}",
"type": "Tipo",
"packet": "Pacote",
"delayMs": "Atraso (ms)",
"applyTo": "Aplicar a",
"addNoise": "+ Ruído",
"concurrency": "Concorrência",
"xudpConcurrency": "Concorrência xudp",
"xudpUdp443": "xudp UDP 443"
},
"mux": "Mux",
"muxDesc": "Transmitir múltiplos fluxos de dados independentes dentro de um fluxo de dados estabelecido.",
"muxSett": "Configurações de Mux",
"direct": "Conexão Direta",
"directDesc": "Estabelece conexões diretamente com domínios ou intervalos de IP de um país específico.",
"notifications": "Notificações",
"certs": "Certificados",
"externalTraffic": "Tráfego Externo",
"dateAndTime": "Data e Hora",
"proxyAndServer": "Proxy e Servidor",
"intervals": "Intervalos",
"information": "Informação",
"profile": "Perfil",
"language": "Idioma",
"telegramBotLanguage": "Idioma do Bot do Telegram",
"security": {
"admin": "Credenciais de administrador",
"twoFactor": "Autenticação de dois fatores",
"twoFactorEnable": "Ativar 2FA",
"twoFactorEnableDesc": "Adiciona uma camada extra de autenticação para mais segurança.",
"twoFactorModalSetTitle": "Ativar autenticação de dois fatores",
"twoFactorModalDeleteTitle": "Desativar autenticação de dois fatores",
"twoFactorModalSteps": "Para configurar a autenticação de dois fatores, siga alguns passos:",
"twoFactorModalFirstStep": "1. Escaneie este QR code no aplicativo de autenticação ou copie o token próximo ao QR code e cole no aplicativo",
"twoFactorModalSecondStep": "2. Digite o código do aplicativo",
"twoFactorModalRemoveStep": "Digite o código do aplicativo para remover a autenticação de dois fatores.",
"twoFactorModalChangeCredentialsTitle": "Alterar credenciais",
"twoFactorModalChangeCredentialsStep": "Insira o código do aplicativo para alterar as credenciais do administrador.",
"twoFactorModalSetSuccess": "A autenticação de dois fatores foi estabelecida com sucesso",
"twoFactorModalDeleteSuccess": "A autenticação de dois fatores foi excluída com sucesso",
"twoFactorModalError": "Código incorreto",
"show": "Mostrar",
"hide": "Ocultar",
"apiTokenNew": "Novo token",
"apiTokenName": "Nome",
"apiTokenNamePlaceholder": "ex.: central-panel-a",
"apiTokenNameRequired": "O nome é obrigatório",
"apiTokenEmpty": "Nenhum token ainda — crie um para autenticar bots ou painéis remotos.",
"apiTokenDeleteWarning": "Qualquer cliente usando este token deixará de se autenticar imediatamente.",
"apiTokenCreatedTitle": "Token criado",
"apiTokenCreatedNotice": "Copie este token agora. Por segurança, ele não é armazenado de forma legível e não será exibido novamente."
},
"toasts": {
"modifySettings": "Os parâmetros foram alterados.",
"getSettings": "Ocorreu um erro ao recuperar os parâmetros.",
"modifyUserError": "Ocorreu um erro ao alterar as credenciais do administrador.",
"modifyUser": "Você alterou com sucesso as credenciais do administrador.",
"originalUserPassIncorrect": "O nome de usuário ou senha atual é inválido",
"userPassMustBeNotEmpty": "O novo nome de usuário e senha não podem estar vazios",
"getOutboundTrafficError": "Erro ao obter tráfego de saída",
"resetOutboundTrafficError": "Erro ao redefinir tráfego de saída"
},
"smtpSettings": "Configurações SMTP",
"smtpEnable": "Ativar notificações por e-mail",
"smtpEnableDesc": "Ativar notificações por e-mail via SMTP",
"smtpHost": "Servidor SMTP",
"smtpHostDesc": "Nome do host do servidor SMTP (ex.: smtp.gmail.com)",
"smtpPort": "Porta SMTP",
"smtpPortDesc": "Porta do servidor SMTP (padrão: 587)",
"smtpUsername": "Usuário SMTP",
"smtpUsernameDesc": "Nome de usuário para autenticação SMTP",
"smtpFrom": "Endereço do remetente (From)",
"smtpFromDesc": "Endereço usado no cabeçalho From do e-mail. Deixe vazio para usar o nome de usuário.",
"smtpFromName": "Nome do remetente (From)",
"smtpFromNameDesc": "Nome de exibição opcional antes do endereço no cabeçalho From.",
"smtpPassword": "Senha SMTP",
"smtpPasswordDesc": "Senha para autenticação SMTP",
"smtpTo": "Destinatários",
"smtpToDesc": "Endereços de e-mail dos destinatários separados por vírgula",
"emailSettings": "E-mail",
"emailNotifications": "Notificações",
"smtpEventBusNotify": "Notificações de eventos por e-mail",
"smtpEventBusNotifyDesc": "Selecione quais eventos disparam notificações por e-mail",
"tgEventBusNotify": "Notificações de eventos no Telegram",
"tgEventBusNotifyDesc": "Selecione quais eventos disparam notificações no Telegram",
"testSmtp": "Enviar e-mail de teste",
"testTgBot": "Enviar mensagem de teste",
"eventGroupOutbound": "Outbound",
"eventGroupXray": "Núcleo Xray",
"eventGroupSystem": "Sistema",
"eventGroupSecurity": "Segurança",
"eventGroupNode": "Nós",
"eventOutboundDown": "Inativo",
"eventOutboundUp": "Ativo",
"eventXrayCrash": "Falha",
"eventNodeDown": "Inativo",
"eventNodeUp": "Ativo",
"eventCPUHigh": "CPU alta (%)",
"requestFailed": "Falha na requisição",
"smtpEncryption": "Criptografia",
"smtpEncryptionDesc": "Método de criptografia da conexão SMTP",
"smtpEncryptionNone": "Nenhuma (texto puro)",
"smtpEncryptionStartTLS": "STARTTLS",
"smtpEncryptionTLS": "TLS (implícito)",
"smtpStageConnect": "Conexão",
"smtpStageAuth": "Autenticação",
"smtpStageSend": "Envio",
"smtpTestSuccess": "E-mail de teste enviado com sucesso",
"smtpHostNotConfigured": "Servidor SMTP não configurado",
"smtpNoRecipients": "Nenhum destinatário configurado",
"smtpFromNotConfigured": "Endereço do remetente SMTP não configurado",
"eventLoginAttempt": "Tentativa de login",
"telegramTokenConfigured": "Configurado; deixe em branco para manter o token atual.",
"telegramTokenPlaceholder": "Configurado - insira um novo token para substituir",
"smtpPasswordConfigured": "Configurada; deixe em branco para manter a senha atual.",
"smtpPasswordPlaceholder": "Configurada - insira uma nova senha para substituir",
"smtpNotInitialized": "SMTP não inicializado",
"tgBotNotEnabled": "O bot do Telegram não está ativado",
"tgTestFailed": "Falha no teste do Telegram",
"tgTestSuccess": "Mensagem de teste enviada ao Telegram",
"tgBotNotRunning": "O bot do Telegram não está em execução",
"smtpErrorAuth": "Falha na autenticação — verifique o nome de usuário e a senha",
"smtpErrorStarttls": "O servidor requer STARTTLS — altere o tipo de criptografia",
"smtpErrorTls": "O servidor requer TLS — altere o tipo de criptografia",
"smtpErrorRefused": "Conexão recusada — verifique o host e a porta",
"smtpErrorTimeout": "Tempo de conexão esgotado — host inacessível",
"smtpErrorRelay": "O servidor rejeita o envio a partir deste endereço",
"smtpErrorEof": "Conexão encerrada pelo servidor",
"smtpErrorUnknown": "Erro de SMTP: {{ .Error }}",
"eventMemoryHigh": "Uso de memória alto (%)",
"remarkTemplate": "Modelo de Observação",
"remarkTemplateDesc": "Quando definido, isto substitui o modelo de observação de cada link de assinatura — escreva seu próprio formato com os tokens de variáveis (use o botão para inseri-los). Deixe vazio para usar o modelo acima.",
"subShowIdentityOnAllLinks": "Mostrar identidade em todos os links",
"subShowIdentityOnAllLinksDesc": "Quando ativado, {{EMAIL}} e {{USERNAME}} permanecem na observação de cada link do corpo da assinatura. Tokens de uso continuam só no primeiro link.",
"validation": {
"pathLeadingSlash": "O caminho deve começar com /"
},
"secretClear": "Limpar",
"secretClearUndo": "Desfazer limpeza",
"calendarGregorian": "Gregorian (Standard)",
"calendarJalalian": "Jalalian (شمسی)",
"ipLimitAllowlist": "Lista de permissões do limite de IP",
"ipLimitAllowlistDesc": "Endereços e redes que o limite de IP nunca conta nem bane, para que um endereço compartilhado de escritório ou campus não esgote o limite de um cliente. IPs/CIDRs separados por vírgula.",
"subBalancers": {
"menu": "Balanceadores de assinatura",
"title": "Balanceador de assinatura",
"add": "Adicionar balanceador",
"desc": "Cada balanceador ativo é adicionado à assinatura JSON como um perfil extra que escolhe automaticamente o melhor endpoint entre os inbounds selecionados.",
"remark": "Descrição",
"remarkPlaceholder": "Auto · mais rápido",
"strategy": "Estratégia",
"strategyLeastLoad": "Menor carga",
"strategyLeastPing": "Menor ping",
"strategyRandom": "Aleatório",
"strategyRoundRobin": "Round robin",
"sortOrder": "Ordem",
"sortOrderHelp": "Posição na lista da assinatura, intercalada com a ordem dos inbounds; em caso de empate, o balanceador vem depois do inbound.",
"inbounds": "Inbounds",
"inboundsCount": "{count} Inbounds",
"enabled": "Ativado",
"empty": "Ainda não há balanceadores",
"deleteConfirm": "Excluir este balanceador?",
"errRemarkRequired": "A descrição é obrigatória",
"errInboundsRequired": "Selecione ao menos um inbound",
"errSortOrder": "A ordem deve ser um inteiro ≥ 1",
"toasts": {
"list": "Falha ao listar os balanceadores de assinatura",
"create": "Falha ao criar o balanceador de assinatura",
"update": "Falha ao atualizar o balanceador de assinatura",
"delete": "Falha ao excluir o balanceador de assinatura",
"invalidId": "Id inválido"
},
"tabBalancers": "Balanceadores",
"tabObservatory": "Observatório",
"observatory": {
"title": "Observatório do balanceador",
"desc": "Parâmetros de probe para o burstObservatory embutido em cada perfil leastPing/leastLoad. random/roundRobin não geram observatório. Salvo como ajuste global da assinatura JSON.",
"destination": "URL de probe",
"destinationDesc": "Endereço que o cliente sonda para medir cada saída membro.",
"connectivity": "URL de conectividade",
"connectivityDesc": "Endereço opcional para verificar uma vez que o membro alcança o destino. Vazio para pular.",
"interval": "Intervalo de probe",
"intervalDesc": "Tempo entre rodadas de probe, p. ex. 1m.",
"timeout": "Tempo limite de probe",
"timeoutDesc": "Tempo limite de cada probe, p. ex. 5s.",
"sampling": "Amostragem",
"samplingDesc": "Número de probes consecutivos para média de estabilidade.",
"httpMethod": "Método HTTP",
"httpMethodDesc": "Método usado nas requisições de probe.",
"note": "Balanceadores leastPing/leastLoad sempre carregam um burstObservatory. Esta opção personaliza seus parâmetros de probe — desligue-a para usar os padrões integrados. As alterações se aplicam após reiniciar o painel."
}
}
},
"xray": {
"importRules": "Importar regras",
"exportRules": "Exportar regras",
"importOutbounds": "Importar saídas",
"exportOutbounds": "Exportar saídas",
"importInvalidJson": "JSON inválido — esperava-se um array ou um objeto com uma chave correspondente.",
"metricsListen": "Endpoint de métricas",
"metricsListenDesc": "Expõe as métricas no estilo Prometheus do Xray neste endereço:porta (por exemplo, 127.0.0.1:11111). Deixe vazio para desativar. Vincule ao localhost e use um proxy reverso — ele não é autenticado.",
"metricsTag": "Tag de métricas",
"save": "Salvar",
"restartSuccess": "Xray foi reiniciado com sucesso",
"stopSuccess": "Xray foi interrompido com sucesso",
"restartError": "Ocorreu um erro ao reiniciar o Xray.",
"stopError": "Ocorreu um erro ao parar o Xray.",
"basicTemplate": "Básico",
"advancedTemplate": "Avançado",
"generalConfigs": "Geral",
"generalConfigsDesc": "Essas opções determinam ajustes gerais.",
"logConfigs": "Log",
"logConfigsDesc": "Os logs podem afetar a eficiência do servidor. É recomendável habilitá-los com sabedoria apenas se necessário.",
"basicRouting": "Roteamento Básico",
"blockConnectionsConfigsDesc": "Essas opções bloquearão o tráfego com base no país solicitado.",
"directConnectionsConfigsDesc": "Uma conexão direta garante que o tráfego específico não seja roteado por outro servidor.",
"blockips": "Bloquear IPs",
"blockdomains": "Bloquear Domínios",
"directips": "IPs Diretos",
"directdomains": "Domínios Diretos",
"ipv4Routing": "Roteamento IPv4",
"ipv4RoutingDesc": "Essas opções roteam o tráfego para um destino específico via IPv4.",
"Template": "Modelo de Configuração Avançada do Xray",
"TemplateDesc": "O arquivo final de configuração do Xray será gerado com base neste modelo.",
"FreedomStrategy": "Estratégia do Protocolo Freedom",
"FreedomStrategyDesc": "Definir a estratégia de saída para a rede no Protocolo Freedom.",
"FreedomHappyEyeballs": "Freedom Happy Eyeballs (IPv4/IPv6)",
"FreedomHappyEyeballsDesc": "Discagem dual-stack para a saída direta (freedom) — útil em servidores de saída com IPv4 e IPv6.",
"FreedomHappyEyeballsTryDelayDesc": "Milissegundos antes de tentar a outra família de endereços. 150–250 ms é um bom ponto de partida.",
"RoutingStrategy": "Estratégia Geral de Roteamento",
"RoutingStrategyDesc": "Definir a estratégia geral de roteamento de tráfego para resolver todas as solicitações.",
"outboundTestUrl": "URL de teste de outbound",
"outboundTestUrlDesc": "URL usada ao testar conectividade do outbound",
"Torrent": "Bloquear Protocolo BitTorrent",
"Inbounds": "Entradas",
"Outbounds": "Saídas",
"Balancers": "Balanceadores",
"balancerTagRequired": "A tag é obrigatória",
"balancerSelectorRequired": "Selecione pelo menos uma saída",
"balancerLive": "Destino atual",
"balancerOverride": "Forçar destino",
"balancerOverridePh": "Automático (estratégia)",
"balancerLiveRefresh": "Atualizar estado do balanceador",
"balancerNotRunning": "Este balanceador não está ativo no Xray em execução — salve as alterações ou inicie o Xray primeiro",
"routeTester": "Teste de rota",
"routeTesterDesc": "Pergunte ao Xray em execução qual saída trataria uma conexão. Nenhum tráfego é enviado — a decisão vem diretamente do motor de roteamento ao vivo.",
"routeTesterDest": "Domínio ou IP",
"routeTesterPort": "Porta",
"routeTesterInbound": "Entrada",
"routeTesterProtocol": "Protocolo detectado",
"routeTesterTest": "Testar rota",
"routeTesterMatchedOutbound": "Saída correspondente",
"routeTesterViaBalancer": "via balanceador",
"routeTesterDefaultOutbound": "Nenhuma regra de roteamento correspondeu — o tráfego vai para a saída padrão (primeira).",
"Routings": "Regras de Roteamento",
"completeTemplate": "Tudo",
"logLevel": "Nível de Log",
"logLevelDesc": "O nível de log para erros, indicando a informação que precisa ser registrada.",
"accessLog": "Log de Acesso",
"accessLogDesc": "O caminho do arquivo para o log de acesso. O valor especial 'none' desativa os logs de acesso.",
"errorLog": "Log de Erros",
"errorLogDesc": "O caminho do arquivo para o log de erros. O valor especial 'none' desativa os logs de erro.",
"dnsLog": "Log DNS",
"dnsLogDesc": "Se ativar logs de consulta DNS",
"maskAddress": "Mascarar Endereço",
"maskAddressDesc": "Máscara de endereço IP, quando ativado, substitui automaticamente o endereço IP que aparece no log.",
"statistics": "Estatísticas",
"statsInboundUplink": "Estatísticas de Upload de Entrada",
"statsInboundDownlink": "Estatísticas de Download de Entrada",
"statsOutboundUplink": "Estatísticas de Upload de Saída",
"statsOutboundDownlink": "Estatísticas de Download de Saída",
"connectionLimits": "Limites de conexão",
"connectionLimitsDesc": "Políticas em nível de conexão para o nível de usuário 0. Deixe um campo vazio para usar o padrão do Xray.",
"connIdle": "Tempo limite de inatividade",
"connIdleDesc": "Fecha uma conexão depois que ela fica inativa por esta quantidade de segundos. Reduzi-lo libera memória e descritores de arquivo mais rápido em servidores ocupados (padrão do Xray: 300).",
"bufferSize": "Tamanho do buffer",
"bufferSizeDesc": "Tamanho do buffer interno por conexão em KB. Defina como 0 para minimizar o uso de memória em servidores com pouca RAM (o padrão do Xray depende da plataforma).",
"bufferSizePlaceholder": "automático",
"seconds": "segundos",
"rules": {
"source": "Fonte",
"dest": "Destino",
"inbound": "Entrada",
"balancer": "Balanceador",
"useComma": "Itens separados por vírgula"
},
"routing": {
"dragToReorder": "Arraste para reordenar"
},
"geoBrowser": {
"title": "Categorias geo",
"openTooltip": "Explorar categorias geo",
"database": "Base de dados",
"searchCategory": "Pesquisar categoria",
"searchEntries": "Filtrar dentro da categoria",
"selectFound": "Selecionar encontradas",
"selected": "Selecionadas: {count}",
"clearAll": "Limpar tudo",
"apply": "Aplicar",
"emptySelection": "Marque as categorias — elas viram tokens da regra",
"pickCategory": "Escolha uma categoria à esquerda para ver o conteúdo",
"noMatches": "Nada encontrado",
"noFiles": "Nenhuma base geo na pasta do Xray",
"noFilesHint": "Elas aparecem depois que o Xray baixa geosite.dat e geoip.dat",
"fileMeta": "{count} categorias · {size} · atualizado em {date}",
"entriesCount": "{count} entradas",
"subnetsCount": "{count} sub-redes",
"shownRange": "Mostrando {from}–{to} de {total}",
"loadFailed": "Não foi possível carregar as bases geo",
"checkFailed": "Não foi possível verificar estes valores nas bases geo",
"parseFailed": "Arquivo corrompido ou não é uma base geosite/geoip",
"tooLarge": "Grande demais para navegar",
"unknownCategories": "Não estão na base: {tokens}",
"missingDatabase": "Arquivo da base não encontrado: {tokens} — adicione-o na seção Geodata",
"unknownAttribute": "Atributo não encontrado, a regra não corresponderá a nada: {tokens}",
"invalidToken": "O Xray não aceitará esta entrada: {tokens}",
"wrongKind": "Tipo de base incorreto para este campo: {tokens}"
},
"ruleForm": {
"sourceIps": "IPs de origem",
"sourcePort": "Porta de origem",
"vlessRoute": "Rota VLESS",
"attributes": "Atributos",
"value": "Valor",
"user": "Usuário",
"userPlaceholder": "Selecionar usuários",
"userEmpty": "Nenhum usuário disponível",
"userLoadError": "Falha ao carregar usuários",
"inboundTags": "Tags de entradas",
"outboundTag": "Tag de saída",
"balancerTag": "Tag de balanceador",
"balancerTagTooltip": "Encaminha tráfego por um dos balanceadores configurados"
},
"outboundForm": {
"tagDuplicate": "Tag já usada por outra saída",
"tagRequired": "A tag é obrigatória",
"tagPlaceholder": "tag-única",
"localIpPlaceholder": "IP local",
"dialerProxyPlaceholder": "Selecione uma saída para encadear",
"dialerProxyHint": "Conecte esta saída através de outra saída (por tag) para criar uma cadeia de proxy. Deixe vazio para conectar diretamente.",
"targetStrategyHint": "Como o domínio de destino é resolvido antes de conectar: AsIs (padrão) envia sem resolver, UseIP… resolve com fallback, ForceIP… exige resolução.",
"addressRequired": "Endereço é obrigatório",
"portRequired": "Porta é obrigatória",
"optional": "opcional",
"udpOverTcp": "UDP sobre TCP",
"uotVersion": "Versão UoT",
"inboundTag": "Tag de entrada",
"inboundTagPlaceholder": "tag de entrada usada em regras de roteamento",
"responseType": "Tipo de resposta",
"rewriteNetwork": "Reescrever rede",
"unchanged": "(inalterado)",
"unchangedAddress": "(inalterado) ex. 1.1.1.1",
"rules": "Regras",
"ruleN": "Regra {n}",
"action": "Ação",
"redirect": "Redirect",
"finalRules": "Regras finais",
"overrideXrayPrivateIp": "Sobrescrever o bloqueio de IP privado padrão do Xray",
"blockDelay": "Atraso do bloqueio (ms)",
"reverseSniffing": "Sniffing reverso",
"reserved": "Reservado",
"minUploadInterval": "Intervalo mín. de upload (ms)",
"maxUploadSizeBytes": "Tamanho máx. de upload (bytes)",
"uplinkChunkSize": "Tamanho do chunk Uplink",
"noGrpcHeader": "Sem cabeçalho gRPC",
"maxConcurrency": "Máx. concorrência",
"maxConnections": "Máx. conexões",
"maxReuseTimes": "Máx. reutilizações",
"maxRequestTimes": "Máx. requisições",
"maxReusableSecs": "Máx. segundos reutilizáveis",
"keepAlivePeriod": "Período keep alive",
"authPassword": "Senha de auth",
"visionTestpre": "Vision testpre",
"serverNamePlaceholder": "nome do servidor",
"verifyPeerName": "Verificar nome do peer",
"pinnedSha256": "SHA256 pinned",
"shortId": "Short ID",
"sockopts": "Sockopts",
"keepAliveInterval": "Intervalo keep alive",
"markFwmark": "Mark (fwmark)",
"interface": "Interface",
"proxyProtocol": "Proxy protocol",
"tcpUserTimeoutMs": "TCP user timeout (ms)",
"tcpKeepAliveIdleS": "TCP keep-alive idle (s)"
},
"outbound": {
"tag": "Tag",
"egress": "Egress",
"egressHint": "Run an HTTP test to show egress IP and country.",
"outboundStatus": "Status de Saída",
"sendThrough": "Enviar Através de",
"targetStrategy": "Estratégia de destino",
"modeRealDelay": "Latência real",
"testModeTooltip": "TCP: sondagem rápida apenas de dial. HTTP: requisição completa pelo xray. Latência real: tempo total incluindo o estabelecimento da conexão.",
"testAll": "Testar todos",
"httpStatus": "Status HTTP",
"breakdownConnect": "Conexão do proxy",
"breakdownTls": "TLS via saída",
"breakdownTtfb": "Primeiro byte",
"country": "País",
"server": "Servidor",
"city": "Cidade",
"allCities": "Todas as Cidades",
"moveToTop": "Mover para o topo"
},
"outboundSub": {
"manage": "Assinaturas",
"title": "Assinaturas de Saída",
"remark": "Observação (opcional)",
"remarkPlaceholder": "ex.: nós de HK",
"url": "URL da assinatura",
"urlPlaceholder": "https://... (lista de links em base64)",
"tagPrefix": "Prefixo da tag",
"tagPrefixPlaceholder": "hk-",
"interval": "Intervalo de atualização",
"hours": "h",
"minutes": "min",
"intervalHint": "Padrão de 10 minutos. A tarefa em segundo plano verifica com frequência; cada assinatura só é buscada novamente quando o seu próprio intervalo é atingido.",
"enabled": "Ativado",
"allowPrivate": "Permitir endereço privado",
"allowPrivateHint": "Permite localhost / LAN / IPs privados para a URL desta assinatura. Desativado por padrão por segurança — ative apenas para uma fonte local confiável.",
"prepend": "Antes das saídas manuais",
"prependHint": "Coloca as saídas desta assinatura antes das suas saídas configuradas manualmente, para que uma delas possa se tornar a padrão.",
"preview": "Pré-visualizar",
"previewEmpty": "Nenhuma saída encontrada nesta URL.",
"refreshAll": "Atualizar todas",
"statusOk": "OK",
"toastUpdated": "Assinatura atualizada",
"addButton": "Adicionar",
"active": "Assinaturas ativas",
"empty": "Nenhuma assinatura ainda. Adicione uma acima.",
"colRemark": "Observação",
"colLastFetch": "Última busca",
"colEnabled": "Ativado",
"auto": "auto",
"never": "nunca",
"refreshNow": "Atualizar agora",
"deleteConfirm": "Excluir esta assinatura?",
"restartHint": "Após adicionar ou atualizar, reinicie o Xray (ou aguarde o próximo recarregamento automático) para ativar as saídas.",
"fromSubsTitle": "De assinaturas de saída (somente leitura)",
"fromSubsDesc": "Importadas das suas assinaturas ativas. Gerencie-as no painel de Assinaturas acima.",
"toastLoadFailed": "Falha ao carregar as assinaturas",
"toastUrlRequired": "A URL da assinatura é obrigatória",
"toastAdded": "Assinatura adicionada",
"toastAddFailed": "Falha ao adicionar a assinatura",
"toastRefreshed": "Atualizado",
"toastRefreshFailed": "Falha na atualização",
"toastDeleted": "Excluído",
"toastDeleteFailed": "Falha ao excluir"
},
"pia": {
"menu": "PIA",
"username": "Usuário PIA",
"password": "Senha PIA",
"account": "Conta",
"region": "Região",
"allRegions": "Todas as regiões",
"noServers": "Nenhum servidor para o país selecionado",
"outboundAdded": "Saída PIA adicionada",
"outboundUpdated": "Saída PIA atualizada",
"addedServers": "Servidores adicionados",
"alreadyAdded": "Este servidor já está na lista de saídas. Use {reset} para renovar a chave.",
"provisionFailed": "Não foi possível criar a saída PIA. Tente novamente."
},
"tabBalancerSettings": "Configurações do balanceador",
"tabObservatory": "Observatório",
"observatory": {
"autoManaged": "Os observadores são gerenciados automaticamente a partir dos seus balanceadores. Ajuste abaixo como eles sondam; as saídas monitoradas seguem os seletores do balanceador.",
"emptyHint": "Nenhum observador de conexão ativo. Um é adicionado automaticamente ao criar um balanceador Least Ping ou Least Load — ou um balanceador Random / Round-robin com fallback — para que balanceadores com observador possam verificar a saúde das saídas antes de escolher um destino.",
"mixedLegacy": "Esta configuração contém Observatory e Burst Observatory ao mesmo tempo. O Xray usa um único observador global, então esse estado misto legado não é suportado; ao salvar os balanceadores ele será normalizado para um único observador.",
"subjectSelector": "Saídas monitoradas",
"subjectSelectorDesc": "Tags de saída que este observador sonda. Gerenciadas automaticamente a partir dos seus balanceadores.",
"probeURL": "URL de sondagem",
"probeURLDesc": "URL requisitada para medir cada saída. Deve retornar HTTP 204.",
"probeInterval": "Intervalo de sondagem",
"probeIntervalDesc": "Com que frequência sondar cada saída, ex.: 30s, 1m, 2h45m.",
"enableConcurrency": "Sondagem concorrente",
"enableConcurrencyDesc": "Sonda todas as saídas monitoradas de uma vez, em vez de uma a uma. Mais rápido, mas mais visível na rede.",
"destination": "Destino da sondagem",
"destinationDesc": "URL requisitada para medir cada saída. Deve retornar HTTP 204.",
"connectivity": "Verificação de conectividade",
"connectivityDesc": "URL opcional de verificação da rede local, testada apenas após o destino falhar. Deixe vazio para ignorar.",
"interval": "Intervalo de sondagem",
"intervalDesc": "Tempo médio entre sondagens por saída, ex.: 1m. Mínimo 10s.",
"timeout": "Tempo limite da sondagem",
"timeoutDesc": "Quanto esperar por uma sondagem antes de considerá-la falha, ex.: 5s.",
"sampling": "Número de amostras",
"samplingDesc": "Número de resultados de sondagem recentes mantidos para pontuar cada saída.",
"httpMethod": "Método HTTP",
"httpMethodDesc": "Método HTTP usado nas sondagens.",
"deleteAlsoObservatory": "Este é o último balanceador que usa o Observatório, então ele também será removido.",
"deleteAlsoBurst": "Este é o último balanceador que usa o Observatório Burst, então ele também será removido."
},
"refCleanup": {
"header": "Excluir isto também atualiza o seu roteamento:",
"ruleRemoved": "Regra {label} — removida (sem destino restante)",
"ruleModified": "Regra {label} — mantida (agora usa {keeps})",
"balancerRemoved": "Balanceador {tag} — removido (sem destinos restantes)"
},
"balancer": {
"balancerStrategy": "Estratégia",
"tag": "Tag",
"tagDuplicate": "Tag já usada por outro balanceador",
"tagPlaceholder": "tag única do balanceador",
"selector": "Seletor",
"fallback": "Fallback",
"cycleTooltip": "Ciclo: {path} → (voltar para {start})",
"expected": "Esperado",
"expectedPlaceholder": "número ótimo de nós",
"maxRtt": "Máx. RTT",
"tolerance": "Tolerância",
"baselines": "Baselines",
"costs": "Costs",
"costMatch": "Padrão de tag",
"costValue": "Peso",
"costRegexp": "Correspondência por expressão regular",
"balancerDeleteInUse": "Não é possível excluir este balanceador — ele é usado como fallback para: {names}",
"balancerFallbackCycle": "Não é possível definir este balanceador como fallback — isso criaria uma dependência circular.",
"balancerFallbackInfo": "O tráfego será roteado através de: Balanceador → Loopback → Servidor → Balanceador de destino → Conexão de saída. Isso adiciona um salto extra pelo servidor, o que pode introduzir pequenos atrasos.",
"fallbackBalancerHint": "Selecione outro balanceador como fallback",
"reservedPrefix": "O prefixo _bl_ é reservado para objetos loopback internos do balanceador"
},
"wireguard": {
"secretKey": "Chave Secreta",
"publicKey": "Chave Pública",
"subnetIp": "Sub-rede",
"subnetCidr": "CIDR da Sub-rede",
"allowedIPs": "IPs Permitidos",
"endpoint": "Ponto Final",
"domainStrategy": "Estratégia de Domínio"
},
"amneziawg": {
"privateKey": "Chave Privada",
"publicKey": "Chave Pública",
"subnetIp": "Sub-rede",
"subnetCidr": "CIDR da Sub-rede",
"mtu": "MTU",
"primaryDns": "DNS Primário",
"secondaryDns": "DNS Secundário",
"externalInterface": "Interface Externa",
"externalInterfaceHint": "Interface de rede do host para NAT (PostUp/PostDown). Deixe vazio para detecção automática.",
"ipv6Enabled": "Ativar IPv6",
"ipv6Subnet": "Sub-rede IPv6",
"ipv6SubnetHint": "ex. fd86:ea04:1115::/64. Obrigatório quando o IPv6 está ativado.",
"ipv6ExternalInterface": "Interface externa IPv6",
"ipv6ExternalInterfaceHint": "Interface de rede do host para as entradas de proxy NDP. Deixe vazio para reutilizar a interface externa.",
"obfuscation": "Parâmetros de ofuscação",
"regenerateObfuscation": "Regenerar",
"jc": "Jc (quantidade de pacotes de lixo)",
"jmin": "Jmin (tamanho mínimo do pacote de lixo)",
"jmax": "Jmax (tamanho máximo do pacote de lixo)",
"s1": "S1 (preenchimento do pacote init)",
"s2": "S2 (preenchimento do pacote response)",
"s3": "S3 (preenchimento de cookie reply)",
"s4": "S4 (preenchimento do pacote de transporte)",
"h1": "H1 (cabeçalho mágico)",
"h2": "H2 (cabeçalho mágico)",
"h3": "H3 (cabeçalho mágico)",
"h4": "H4 (cabeçalho mágico)",
"hHint": "Um número inteiro ou um intervalo. Deixe vazio para os valores clássicos 1/2/3/4.",
"i1": "I1 (pacote de assinatura)",
"i1Hint": "Pacote de assinatura opcional. Deixe vazio para omiti-lo.",
"i2": "I2 (pacote de assinatura)",
"i3": "I3 (pacote de assinatura)",
"i4": "I4 (pacote de assinatura)",
"i5": "I5 (pacote de assinatura)",
"headerProtectionKey": "HeaderProtectionKey (proteção de cabeçalhos)",
"headerProtectionKeyHint": "Chave Base64 de 32 bytes; deve coincidir na configuração de cada cliente. Deixe vazio para desativar a proteção de cabeçalhos.",
"contentPaddingAddition": "ContentPaddingAddition (preenchimento de conteúdo)",
"contentPaddingAdditionHint": "Um inteiro ou um intervalo de bytes adicionado aos pacotes de conteúdo. Deixe vazio para desativar.",
"rekeyAfterTime": "RekeyAfterTime (segundos)",
"rekeyTimeout": "RekeyTimeout (segundos)",
"rejectAfterTime": "RejectAfterTime (segundos)",
"keepaliveTimeout": "KeepaliveTimeout (segundos)",
"maxHandshakeAttempts": "MaxHandshakeAttempts",
"timingRangeHint": "Um inteiro ou um intervalo. Deixe vazio para manter o padrão do WireGuard.",
"maxHandshakeAttemptsHint": "Tentativas de handshake antes de desistir. Deixe vazio para o padrão.",
"randomTrailers": "RandomTrailers",
"randomTrailersHint": "Acrescenta bytes aleatórios a cada pacote. Ambos os lados precisam do AmneziaWG 3.1+.",
"disableCookies": "DisableCookies",
"disableCookiesHint": "Nunca enviar cookie replies — remove uma impressão digital de DPI, mas enfraquece a mitigação de inundações."
},
"tun": {
"userLevel": "Nível do Usuário"
},
"nord": {
"accessToken": "Access token",
"privateKey": "Chave privada",
"noServers": "Nenhum servidor encontrado para o país selecionado",
"noPublicKey": "O servidor selecionado não anuncia uma chave pública NordLynx.",
"outboundAdded": "Saída NordVPN adicionada",
"outboundUpdated": "Saída NordVPN atualizada"
},
"warp": {
"changeIp": "Alterar IP",
"changeIpSuccess": "IP do WARP alterado com sucesso!",
"autoUpdateIp": "Atualizar endereço IP automaticamente",
"intervalDays": "Intervalo (dias)",
"intervalDesc": "0 para desativar. Altera o endereço IP automaticamente.",
"licenseError": "Falha ao definir licença WARP.",
"fetchFirst": "Obtenha primeiro a configuração WARP.",
"createAccount": "Criar conta WARP",
"accessToken": "Access token",
"deviceId": "ID do dispositivo",
"licenseKey": "Chave de licença",
"privateKey": "Chave privada",
"deleteAccount": "Excluir conta",
"settings": "Configurações",
"licenseKeyLabel": "Chave de licença WARP / WARP+",
"key": "Chave",
"keyPlaceholder": "chave WARP+ de 26 caracteres",
"accountInfo": "Informação da conta",
"deviceName": "Nome do dispositivo",
"deviceModel": "Modelo do dispositivo",
"deviceEnabled": "Dispositivo habilitado",
"accountType": "Tipo de conta",
"role": "Função",
"warpPlusData": "Dados WARP+",
"quota": "Quota",
"usage": "Uso",
"addOutbound": "Adicionar saída"
},
"dns": {
"enable": "Ativar DNS",
"enableDesc": "Ativar o servidor DNS integrado",
"tag": "Tag de Entrada DNS",
"tagDesc": "Esta tag estará disponível como uma tag de Entrada nas regras de roteamento.",
"clientIp": "IP do Cliente",
"clientIpDesc": "Usado para notificar o servidor sobre a localização IP especificada durante consultas DNS",
"disableCache": "Desativar cache",
"disableCacheDesc": "Desativa o cache de DNS",
"disableFallback": "Desativar Fallback",
"disableFallbackDesc": "Desativa consultas DNS de fallback",
"disableFallbackIfMatch": "Desativar Fallback Se Corresponder",
"disableFallbackIfMatchDesc": "Desativa consultas DNS de fallback quando a lista de domínios correspondentes do servidor DNS é atingida",
"enableParallelQuery": "Habilitar Consulta Paralela",
"enableParallelQueryDesc": "Habilitar consultas DNS paralelas para múltiplos servidores para resolução mais rápida",
"strategy": "Estratégia de Consulta",
"strategyDesc": "Estratégia geral para resolver nomes de domínio",
"add": "Adicionar Servidor",
"edit": "Editar Servidor",
"domains": "Domínios",
"expectIPs": "IPs Esperadas",
"unexpectIPs": "IPs inesperados",
"useSystemHosts": "Usar Hosts do sistema",
"useSystemHostsDesc": "Usar o arquivo hosts de um sistema instalado",
"serveStale": "Servir Expirados",
"serveStaleDesc": "Retornar resultados expirados do cache enquanto atualiza em segundo plano",
"serveExpiredTTL": "TTL de Expirados",
"serveExpiredTTLDesc": "Validade (segundos) das entradas expiradas no cache; 0 = nunca expira",
"timeoutMs": "Tempo limite (ms)",
"skipFallback": "Ignorar Fallback",
"finalQuery": "Consulta Final",
"hosts": "Hosts",
"hostsAdd": "Adicionar Host",
"hostsEmpty": "Nenhum Host definido",
"hostsDomain": "Domínio (ex. domain:example.com)",
"hostsValues": "IP ou domínio — digite e pressione Enter",
"usePreset": "Usar modelo",
"dnsPresetTitle": "Modelos DNS",
"dnsPresetFamily": "Familiar",
"clearAll": "Remover Todos",
"clearAllTitle": "Remover todos os servidores DNS?",
"clearAllConfirm": "Isso remove todos os servidores DNS da lista. Não pode ser desfeito.",
"dnsLeakWarning": "DNS pode vazar por localhost, UDP/TCP sem criptografia, DoH/DoQ em modo local, consultas de fallback ou EDNS client IP. Use DoH roteado, fixe resolvedores em hosts e desative fallback quando privacidade importar."
},
"fakedns": {
"add": "Adicionar Fake DNS",
"ipPool": "Sub-rede do Pool de IP",
"poolSize": "Tamanho do Pool"
},
"defaultOutbound": "Saída padrão",
"defaultOutboundDesc": "Tráfego sem regra de roteamento usa esta saída (a primeira da lista)."
},
"hosts": {
"addHost": "Adicionar Host",
"editHost": "Editar Host",
"selectInbound": "Selecione uma entrada",
"selectedCount": "{count} selecionado(s)",
"summary": {
"total": "Total",
"enabled": "Ativados",
"disabled": "Desativados"
},
"moveUp": "Mover para cima",
"moveDown": "Mover para baixo",
"bulkEnable": "Ativar",
"bulkDisable": "Desativar",
"bulkDelete": "Excluir",
"bulkDeleteConfirm": "Excluir {count} host(s) selecionado(s)?",
"deleteConfirmTitle": "Excluir o host \"{name}\"?",
"sections": {
"basic": "Básico",
"security": "Segurança",
"advanced": "Avançado",
"general": "Geral",
"clash": "Clash (mihomo)"
},
"fields": {
"remark": "Observação",
"serverDescription": "Descrição",
"inbound": "Entradas",
"address": "Endereço",
"port": "Porta",
"endpoint": "Endpoint",
"enable": "Ativado",
"actions": "Ações",
"security": "Segurança",
"sni": "SNI",
"overrideSniFromAddress": "Usar endereço como SNI",
"keepSniBlank": "Manter SNI em branco",
"hostHeader": "Cabeçalho Host",
"path": "Caminho",
"alpn": "ALPN",
"fingerprint": "Fingerprint",
"pins": "SHA-256 do certificado fixado",
"verifyPeerCertByName": "Verificar certificado do par pelo nome",
"allowInsecure": "Permitir inseguro",
"echConfigList": "Lista de configurações ECH",
"muxParams": "Mux",
"sockoptParams": "Sockopt",
"finalMask": "Final Mask",
"vlessRoute": "Rota VLESS",
"mihomoIpVersion": "Versão de IP",
"mihomoX25519": "Mihomo X25519",
"shuffleHost": "Embaralhar host",
"tags": "Tags",
"nodeGuids": "Nós",
"excludeFromSubTypes": "Excluir dos formatos",
"inheritAddress": "Herda endereço"
},
"hints": {
"address": "Deixe em branco para herdar o próprio endereço da entrada.",
"port": "0 herda a porta da entrada.",
"tags": "Não visível aos usuários finais; enviado apenas na assinatura RAW. Apenas letras maiúsculas, dígitos, _ e :.",
"nodeGuids": "Escolha os nós que foram resolvidos a partir deste host. Apenas atribuição visual.",
"serverDescription": "Nota opcional exibida abaixo da observação.",
"allowInsecure": "Ignorar a verificação do certificado TLS (allowInsecure / skip-cert-verify).",
"vlessRoute": "Um único valor de rota VLESS (0-65535) embutido no UUID, ex.: 443. Deixe em branco para nenhum.",
"remark": "Um rótulo simples para este host. Mostrado como nome da configuração apenas quando a entrada não tem observação própria."
},
"remarkVars": {
"title": "Variáveis de Modelo",
"intro": "Clique em uma variável para adicioná-la. Ela é substituída por cliente quando a assinatura é gerada.",
"preview": "Pré-visualização",
"groups": {
"client": "Cliente",
"traffic": "Tráfego",
"time": "Tempo e status",
"connection": "Conexão"
},
"descEMAIL": "Email do cliente",
"descINBOUND": "Observação da própria entrada (nome da configuração)",
"descHOST": "Observação do host",
"descID": "UUID do cliente",
"descSHORT_ID": "Primeiros 8 caracteres do UUID",
"descTELEGRAM_ID": "ID do Telegram do cliente (vazio se não definido)",
"descSUB_ID": "ID da assinatura",
"descCOMMENT": "Comentário do cliente",
"descTRAFFIC_USED": "Tráfego usado (legível por humanos)",
"descTRAFFIC_LEFT": "Tráfego restante (oculto se ilimitado)",
"descTRAFFIC_TOTAL": "Tráfego total (oculto se ilimitado)",
"descTRAFFIC_USED_BYTES": "Tráfego usado em bytes",
"descTRAFFIC_LEFT_BYTES": "Tráfego restante em bytes",
"descTRAFFIC_TOTAL_BYTES": "Tráfego total em bytes",
"descUP": "Tráfego de upload",
"descDOWN": "Tráfego de download",
"descSTATUS": "ativo / expirado / desativado / esgotado",
"descSTATUS_EMOJI": "Status como emoji (✅ ⏳ 🚫)",
"descDAYS_LEFT": "Dias até a expiração (oculto se ilimitado)",
"descTIME_LEFT": "Tempo restante (ex.: 12d 4h 30m)",
"descUSAGE_PERCENTAGE": "Tráfego usado como porcentagem (oculto se ilimitado)",
"descEXPIRE_DATE": "Data de expiração (AAAA-MM-DD)",
"descJALALI_EXPIRE_DATE": "Data de expiração no calendário Jalali (AAAA/MM/DD)",
"descEXPIRE_UNIX": "Expiração como timestamp Unix (segundos)",
"descCREATED_UNIX": "Data de criação como timestamp Unix (segundos)",
"descRESET_DAYS": "Período de redefinição de tráfego em dias",
"descRESET_DAY": "Dia do mês em que é renovado",
"descPROTOCOL": "Protocolo da entrada (VLESS, VMess, Trojan, …)",
"descTRANSPORT": "Rede de transporte (tcp, ws, grpc, …)",
"descSECURITY": "Segurança do transporte (TLS, REALITY, NONE)"
},
"toasts": {
"list": "Falha ao carregar os hosts",
"obtain": "Falha ao carregar o host",
"add": "Adicionar host",
"update": "Atualizar host",
"delete": "Excluir host",
"badTag": "Tag inválida",
"badVlessRoute": "Insira um único número entre 0 e 65535"
}
}
},
"tgbot": {
"keyboardClosed": "❌ Teclado fechado!",
"noResult": "❗ Nenhum resultado!",
"noQuery": "❌ Consulta não encontrada! Por favor, use o comando novamente!",
"wentWrong": "❌ Algo deu errado!",
"noIpRecord": "❗ Nenhum registro de IP!",
"noInbounds": "❗ Nenhum inbound encontrado!",
"unlimited": "♾ Ilimitado (Reset)",
"add": "Adicionar",
"month": "Mês",
"months": "Meses",
"days": "Dias",
"hours": "Horas",
"minutes": "Minutos",
"unknown": "Desconhecido",
"inbounds": "Entradas",
"clients": "Clientes",
"offline": "🔴 Offline",
"online": "🟢 Online",
"commands": {
"unknown": "❗ Comando desconhecido.",
"pleaseChoose": "👇 Escolha:\r\n",
"help": "🤖 Bem-vindo a este bot! Ele foi projetado para oferecer dados específicos do painel da web e permite que você faça as modificações necessárias.\r\n\r\n",
"start": "👋 Olá <i>{{ .Firstname }}</i>.\r\n",
"welcome": "🤖 Bem-vindo ao bot de gerenciamento do <b>{{ .Hostname }}</b>.\r\n",
"status": "✅ Bot está OK!",
"usage": "❗ Por favor, forneça um texto para pesquisar!",
"getID": "🆔 Seu ID: <code>{{ .ID }}</code>",
"helpAdminCommands": "Para reiniciar o Xray Core:\r\n<code>/restart</code>\r\n\r\nPara pesquisar por um email de cliente:\r\n<code>/usage [Email]</code>\r\n\r\nPara pesquisar por inbounds (com estatísticas do cliente):\r\n<code>/inbound [Remark]</code>\r\n\r\nTelegram Chat ID:\r\n<code>/id</code>",
"helpClientCommands": "Para pesquisar por estatísticas, use o seguinte comando:\r\n\r\n<code>/usage [Email]</code>\r\n\r\nTelegram Chat ID:\r\n<code>/id</code>",
"restartUsage": "\r\n\r\n<code>/restart</code>",
"restartSuccess": "✅ Operação bem-sucedida!",
"restartFailed": "❗ Erro na operação.\r\n\r\n<code>Erro: {{ .Error }}</code>.",
"xrayNotRunning": "❗ Xray Core não está em execução.",
"startDesc": "Mostrar menu principal",
"helpDesc": "Ajuda do bot",
"statusDesc": "Verificar status do bot",
"idDesc": "Mostrar seu ID do Telegram",
"usageDesc": "Ver o uso do cliente: /usage email",
"inboundDesc": "Buscar entradas: /inbound nome (admin)",
"restartDesc": "Reiniciar o núcleo Xray (admin)",
"clearallDesc": "Zerar o tráfego de todos os clientes (admin)"
},
"messages": {
"cpuThreshold": "A carga da CPU {{ .Percent }}% excede o limite de {{ .Threshold }}%",
"selectUserFailed": "❌ Erro na seleção do usuário!",
"userSaved": "✅ Usuário do Telegram salvo.",
"loginSuccess": "✅ Conectado ao painel com sucesso.\r\n",
"loginFailed": "❗️Tentativa de login no painel falhou.\r\n",
"report": "🕰 Relatórios agendados: {{ .RunTime }}\r\n",
"datetime": "⏰ Data&Hora: {{ .DateTime }}\r\n",
"hostname": "💻 Host: {{ .Hostname }}\r\n",
"version": "🚀 Versão 3X-UI: {{ .Version }}\r\n",
"xrayVersion": "📡 Versão Xray: {{ .XrayVersion }}\r\n",
"ipv6": "🌐 IPv6: {{ .IPv6 }}\r\n",
"ipv4": "🌐 IPv4: {{ .IPv4 }}\r\n",
"ip": "🌐 IP: {{ .IP }}\r\n",
"ips": "🔢 IPs:\r\n{{ .IPs }}\r\n",
"serverUpTime": "⏳ Tempo de atividade: {{ .UpTime }} {{ .Unit }}\r\n",
"serverLoad": "📈 Carga do sistema: {{ .Load1 }}, {{ .Load2 }}, {{ .Load3 }}\r\n",
"serverMemory": "📋 RAM: {{ .Current }}/{{ .Total }}\r\n",
"tcpCount": "🔹 TCP: {{ .Count }}\r\n",
"udpCount": "🔸 UDP: {{ .Count }}\r\n",
"traffic": "🚦 Tráfego: {{ .Total }} (↑{{ .Upload }},↓{{ .Download }})\r\n",
"xrayStatus": "ℹ️ Status: {{ .State }}\r\n",
"username": "👤 Nome de usuário: {{ .Username }}\r\n",
"reason": "❗️ Motivo: {{ .Reason }}\r\n",
"time": "⏰ Hora: {{ .Time }}\r\n",
"inbound": "📍 Entrada: {{ .Remark }}\r\n",
"port": "🔌 Porta: {{ .Port }}\r\n",
"expire": "📅 Data de expiração: {{ .Time }}\r\n",
"expireIn": "📅 Expira em: {{ .Time }}\r\n",
"active": "💡 Ativo: {{ .Enable }}\r\n",
"enabled": "🚨 Ativado: {{ .Enable }}\r\n",
"online": "🌐 Status da conexão: {{ .Status }}\r\n",
"lastOnline": "🔙 Última vez online: {{ .Time }}\r\n",
"email": "📧 Email: {{ .Email }}\r\n",
"upload": "🔼 Upload: ↑{{ .Upload }}\r\n",
"download": "🔽 Download: ↓{{ .Download }}\r\n",
"total": "📊 Total: ↑↓{{ .UpDown }} / {{ .Total }}\r\n",
"TGUser": "👤 Usuário do Telegram: {{ .TelegramID }}\r\n",
"exhaustedCount": "🚨 Contagem de {{ .Type }} esgotado:\r\n",
"onlinesCount": "🌐 Clientes online: {{ .Count }}\r\n",
"disabled": "🛑 Desativado: {{ .Disabled }}\r\n",
"depleteSoon": "🔜 Esgotar em breve: {{ .Deplete }}\r\n\r\n",
"backupTime": "🗄 Hora do backup: {{ .Time }}\r\n",
"refreshedOn": "\r\n📋🔄 Atualizado em: {{ .Time }}\r\n\r\n",
"yes": "✅ Sim",
"no": "❌ Não",
"received_email": "📧📥 E-mail atualizado.",
"received_comment": "💬📥 Comentário atualizado.",
"email_prompt": "📧 E-mail Padrão: {{ .ClientEmail }}\n\nDigite seu e-mail.",
"comment_prompt": "💬 Comentário Padrão: {{ .ClientComment }}\n\nDigite seu comentário.",
"cancel": "❌ Processo Cancelado! \n\nVocê pode iniciar novamente a qualquer momento com /start. 🔄",
"error_add_client": "⚠️ Erro:\n\n {{ .error }}",
"using_default_value": "Tudo bem, vou manter o valor padrão. 😊",
"incorrect_input": "Sua entrada não é válida.\nAs frases devem ser contínuas, sem espaços.\nExemplo correto: aaaaaa\nExemplo incorreto: aaa aaa 🚫",
"AreYouSure": "Você tem certeza? 🤔",
"SuccessResetTraffic": "📧 Email: {{ .ClientEmail }}\n🏁 Resultado: ✅ Sucesso",
"FailedResetTraffic": "📧 Email: {{ .ClientEmail }}\n🏁 Resultado: ❌ Falhou \n\n🛠️ Erro: [ {{ .ErrorMessage }} ]",
"FinishProcess": "🔚 Processo de redefinição de tráfego concluído para todos os clientes.",
"eventOutboundDown": "O outbound {{ .Tag }} está INATIVO",
"eventOutboundUp": "O outbound {{ .Tag }} está ATIVO",
"eventErrorDetail": "Erro: {{ .Error }}",
"eventDelayDetail": "Latência: {{ .Delay }}ms",
"eventXrayCrash": "O Xray FALHOU",
"eventXrayCrashError": "Erro: {{ .Error }}",
"eventNodeDown": "O nó {{ .Name }} está INATIVO",
"eventNodeUp": "O nó {{ .Name }} está ATIVO",
"eventLoginFallback": "Falha de login a partir de {{ .Source }}",
"memoryThreshold": "Uso de memória {{ .Percent }}% excede o limite de {{ .Threshold }}%"
},
"buttons": {
"closeKeyboard": "❌ Fechar teclado",
"cancel": "❌ Cancelar",
"cancelReset": "❌ Cancelar redefinição",
"cancelIpLimit": "❌ Cancelar limite de IP",
"confirmResetTraffic": "✅ Confirmar redefinição de tráfego?",
"confirmClearIps": "✅ Confirmar limpar IPs?",
"confirmRemoveTGUser": "✅ Confirmar remover usuário do Telegram?",
"confirmToggle": "✅ Confirmar ativar/desativar usuário?",
"dbBackup": "Obter backup do DB",
"serverUsage": "Uso do servidor",
"getInbounds": "Obter Inbounds",
"depleteSoon": "Esgotar em breve",
"clientUsage": "Obter uso",
"onlines": "Clientes online",
"commands": "Comandos",
"refresh": "🔄 Atualizar",
"clearIPs": "❌ Limpar IPs",
"removeTGUser": "❌ Remover usuário do Telegram",
"selectTGUser": "👤 Selecionar usuário do Telegram",
"selectOneTGUser": "👤 Selecione um usuário do Telegram:",
"resetTraffic": "📈 Redefinir tráfego",
"resetExpire": "📅 Alterar data de expiração",
"ipLog": "🔢 Log de IP",
"ipLimit": "🔢 Limite de IP",
"setTGUser": "👤 Definir usuário do Telegram",
"toggle": "🔘 Ativar / Desativar",
"custom": "🔢 Personalizado",
"confirmNumber": "✅ Confirmar: {{ .Num }}",
"confirmNumberAdd": "✅ Confirmar adicionar: {{ .Num }}",
"limitTraffic": "🚧 Limite de tráfego",
"getBanLogs": "Obter logs de banimento",
"allClients": "Todos os clientes",
"addClient": "Adicionar Cliente",
"submitDisable": "Enviar como Desativado ☑️",
"submitEnable": "Enviar como Ativado ✅",
"use_default": "🏷️ Usar padrão",
"change_email": "⚙️📧 Email",
"change_comment": "⚙️💬 Comentário",
"ResetAllTraffics": "Redefinir Todo o Tráfego",
"SortedTrafficUsageReport": "Relatório de Uso de Tráfego Ordenado"
},
"answers": {
"successfulOperation": "✅ Operação bem-sucedida!",
"errorOperation": "❗ Erro na operação.",
"getInboundsFailed": "❌ Falha ao obter inbounds.",
"getClientsFailed": "❌ Falha ao obter clientes.",
"canceled": "❌ {{ .Email }}: Operação cancelada.",
"clientRefreshSuccess": "✅ {{ .Email }}: Cliente atualizado com sucesso.",
"IpRefreshSuccess": "✅ {{ .Email }}: IPs atualizados com sucesso.",
"TGIdRefreshSuccess": "✅ {{ .Email }}: Usuário do Telegram do cliente atualizado com sucesso.",
"resetTrafficSuccess": "✅ {{ .Email }}: Tráfego redefinido com sucesso.",
"setTrafficLimitSuccess": "✅ {{ .Email }}: Limite de tráfego salvo com sucesso.",
"expireResetSuccess": "✅ {{ .Email }}: Dias de expiração redefinidos com sucesso.",
"resetIpSuccess": "✅ {{ .Email }}: Limite de IP {{ .Count }} salvo com sucesso.",
"clearIpSuccess": "✅ {{ .Email }}: IPs limpos com sucesso.",
"getIpLog": "✅ {{ .Email }}: Obter log de IP.",
"getUserInfo": "✅ {{ .Email }}: Obter informações do usuário do Telegram.",
"removedTGUserSuccess": "✅ {{ .Email }}: Usuário do Telegram removido com sucesso.",
"enableSuccess": "✅ {{ .Email }}: Ativado com sucesso.",
"disableSuccess": "✅ {{ .Email }}: Desativado com sucesso.",
"askToAddUserId": "Sua configuração não foi encontrada!\r\nPeça ao seu administrador para usar seu Telegram ChatID em suas configurações.\r\n\r\nSeu ChatID: <code>{{ .TgUserID }}</code>",
"chooseClient": "Escolha um cliente para Inbound {{ .Inbound }}",
"chooseInbound": "Escolha um Inbound"
}
},
"email": {
"labelStatus": "Status",
"labelOutbound": "Outbound",
"labelNode": "Nó",
"labelError": "Erro",
"labelDelay": "Latência",
"labelUsername": "Nome de usuário",
"labelIP": "IP",
"labelReason": "Motivo",
"labelSource": "Origem",
"statusCrashed": "FALHOU",
"statusHigh": "ALTA",
"statusSuccess": "SUCESSO",
"statusFailed": "FALHOU",
"statusDown": "INATIVO",
"statusUp": "ATIVO"
}
}
Reference in New Issue View Git Blame Copy Permalink