Skip to content

About

Plexus — cross-platform network site planner: WiFi + IP cameras + switches/PoE. Predictive wall-aware ray-cast coverage, SNR/throughput heatmaps, topology & cabling, branded PDF/BoM exports. Desktop apps for macOS/Windows/Linux, or runs offline in the browser.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

4 stars

Watchers

0 watching

Forks

Latest commit

 

History

88 Commits

Folders and files

Repository files navigation

Plexus

Plan it. Simulate it. Operate it.
Predictive WiFi & camera design · a Packet-Tracer-class network simulator · live device operation — one app, no backend.

Release CI Desktop Tests License: MIT Vanilla JS

▶ Try it in your browser — nothing to install; click Load sample project.

Plexus — signal heatmap through walls, with an access point selected

Dragging an AP — wall-aware coverage re-clips in real time
Drag an access point: its coverage re-clips against the walls as it moves.

At a glance

Signal heatmap Packet simulation
Design — place APs, cameras and switches on a floor plan; coverage and heatmaps follow the walls and the floors above and below. Simulate — the same plan forwards packets: VLANs, routing, ACLs, NAT, OSPF/RIP, with a step-by-step trace on the map.
Policies Device config and drift
Prove intent — write what must and must never be reachable; the simulator names every pair that breaks it. Plan → device — generate the RouterOS config per switch, then check the real device against the plan.
Client report A router with built-in WiFi
Hand over — a client report with coverage, equipment and sign-off, and no addresses or credentials in it. Real hardware — 600+ models; routers with a built-in radio cover the floor like an AP.

What makes it different

  • One model, three uses. The drawing is the simulation is the device config. Nothing is re-entered.
  • It never touches a device on its own. Reading a config is one fixed read-only command; pushing one is a rosconf dry run that you turn into an apply.
  • No backend, no account. A project is a single JSON file. Credentials can be encrypted in it with a passphrase.
  • Untrusted by default. A project file from someone else is treated as hostile input everywhere — in the page, in the SSH launcher, in the file dialogs.

Table of contents

  1. What is Plexus?
  2. The three modes
  3. Install
  4. Tutorial 1 — Design a WiFi plan
  5. Tutorial 2 — Simulate the network
  6. Tutorial 3 — Operate: connect to a real device
  7. Feature reference
  8. Keyboard shortcuts
  9. How it works (architecture)
  10. The coverage math
  11. Build & desktop installers
  12. Tests
  13. Project layout
  14. Project file format
  15. Roadmap · Contributing · Security · License

What is Plexus?

Plexus is a network site planner, simulator and operator in a single app that runs in any browser or as a native desktop build. You design a network on a floor plan, turn that same design into a working simulated network you can ping and configure over a Cisco/MikroTik CLI, and then connect to the real gear over SSH — all from the same canvas. No backend, no accounts; a project is one JSON file you can email.

Live demo (deployed from main) · Download the latest release for macOS .dmg, Windows .exe, Linux .AppImage/.deb, or the portable browser zip · Changelog


The three modes

Plexus has one canvas and three workspace modes. The top-bar switcher changes which tools are available, so each mode stays focused.

flowchart LR
    A["Design<br/>place devices · draw walls<br/>RF coverage &amp; heatmaps"]
    B["Simulate<br/>ping / traceroute · VLANs<br/>OSPF/RIP · IOS/RouterOS CLI"]
    C["Operate<br/>connect to real devices<br/>over SSH (desktop only)"]
    A --> B --> C
    C -. "same project" .-> A
Loading
Mode What you do Key
Design Lay out APs, cameras, switches/routers, walls; read wall-aware coverage + heatmaps. A
Simulate Run packets on your design: VLANs, routing, DHCP/DNS/NAT, a per-device CLI. M
Operate Open an SSH session to the real device you clicked. Desktop build only, behind a confirmation. —

Install

Option A — browser (zero install)

Open the live demo, or grab the portable zip from Releases, unzip, and open index.html. Fully offline, runs from file://.

The browser build does everything except the desktop-only features (Operate / SSH, live WiFi survey, UniFi sync) — those need the native app.

Option B — desktop app (recommended)

Download the installer for your OS from Releases:

OS File First-launch note (unsigned build)
macOS .dmg / .zip Right-click → Open → Open. If still blocked: xattr -dr com.apple.quarantine "/Applications/Plexus.app"
Windows .exe (NSIS) SmartScreen → More info → Run anyway
Linux .AppImage / .deb chmod +x *.AppImage then run

Option C — from source

git clone https://github.com/s-markakis/plexus-network-planner
cd plexus-network-planner
npm install
npm run dev          # browser dev server → http://localhost:5173
npm run app:dev      # OR launch the desktop app

Requires Node 18+ (LTS recommended).


Tutorial 1 — Design a WiFi plan

Goal: a floor plan with wall-aware coverage and a signal heatmap.

  1. Start a project. Click Load sample project to start populated, New from template… for a villa / hotel / restaurant with its VLAN plan and policies already written, or Upload Map and pick a floor plan (PNG / JPG / SVG / PDF).
  2. Set the scale. Click Calibrate, draw a line over a dimension you know (a doorway, a wall), and type its real length — or type Scale directly as metres per 100 px. High-resolution plans are fine: the scale can be well below 1 m / 100 px, and every device keeps its range in metres when the scale changes. With a scale set, the heatmap uses physical, FSPL-based path loss.
  3. Draw walls. Press L and drag (hold Shift to snap to 45°). Pick a material — drywall, glass, brick, concrete — each attenuates differently. Or import walls from an SVG/DXF, or auto-detect them from the bitmap.
  4. Place access points. Press A and click (the drawing tools are the palette on the left edge of the map). Each AP renders its actual wall-clipped coverage polygon, not a circle. A router with a built-in radio (UniFi Dream Router, MikroTik hAP, …) placed with the switch tool gets coverage too — see Routers with WiFi.
  5. Turn on the heatmap. Open Layers → Heatmap, then cycle the metric pill through RSSI → SNR → SINR → MCS → Throughput. With several floors, Settings → Include other floors in heatmap adds the APs above and below, through the slabs.
  6. Optimize. Use Auto-place (drop APs to hit 92% coverage), Auto-channel (graph-colouring), and Auto-power.
  7. Deliver. Export a branded PDF, BoM/cable-schedule CSV, or a one-zip Handover pack.
Wall-clipped coverage + camera FoV cones RSSI heatmap
Coverage polygons — wall-clipped, with camera FoV cones Heatmap — RSSI (ITU-R P.1238 indoor model)
More screenshots — throughput heatmap, cable runs, templates, settings, light theme
Throughput heatmap Cable runs to switches
Estimated-throughput heatmap Cable runs to switches, with lengths
Site templates Settings
Site templates: VLAN plan, policies and naming per kind of site Project settings

Light theme

Light theme. Every image here comes from the bundled sample (files/src/sampleProject.js) and is regenerated with npm run docs:media (scripts/media/readme-media.spec.js; the GIF needs ffmpeg).


Tutorial 2 — Simulate the network

Goal: make the design forward real packets, route between VLANs, and take CLI config.

Switch to Simulate (press M). The packet-sim panel opens.

Packet simulation: a guest AP pings a camera across the L3 core

Ping across the topology

  1. Pick a source and destination device.
  2. Click Ping — an animated PDU walks the map hop by hop; the step inspector shows each decision (ARP → L2 forward → L3 route → deliver).
sequenceDiagram
    autonumber
    participant PC1 as PC-1 (VLAN 10)
    participant R as L3 Switch
    participant PC2 as PC-2 (VLAN 20)
    PC1->>R: ARP who-has gateway?
    R-->>PC1: ARP reply (SVI MAC)
    PC1->>R: ICMP echo → 10.0.20.x
    Note over R: route lookup<br/>longest-prefix match
    R->>PC2: ICMP echo (routed)
    PC2-->>PC1: ICMP echo-reply
Loading

Configure a device from the CLI

Select a switch/router → CLI Console. Type real Cisco IOS or MikroTik RouterOS; the simulator forwards accordingly.

# Cisco IOS — inter-VLAN routing on an SVI
interface vlan 20
 ip address 10.0.20.1 255.255.255.0
 no shutdown
!
router ospf 1
 network 10.0.0.0 0.0.255.255 area 0
# MikroTik RouterOS — the equivalent
/ip address add address=10.0.20.1/24 interface=vlan20
/routing ospf instance add name=default
/routing ospf network add network=10.0.0.0/16 area=backbone

What the simulator models: L2 switching + VLANs + MAC learning, ARP, L3 routing (connected/static + OSPF and RIP), DHCP, name-based DNS (ping AP-01 resolves), NAT/PAT, ACL/firewall, an internet cloud, and link-down fault injection. Drop a wireless client (K) and it associates to the best AP by real signal, then gets a DHCP lease.

Testing a design in the sim panel

  • Ping / Traceroute between any two endpoints — and to gateways, switch management addresses and the Internet (they appear as extra "To" targets).

  • Probe port — "can the camera open tcp/554 on the NVR?" → open, closed (nothing listening) or filtered (a firewall rule dropped it).

  • Faults — power off a switch or cut an uplink, then re-run the test. Routes over the dead link are withdrawn and OSPF/RIP reconverge on what is left.

  • VLAN matrix — every VLAN against every other: ✓ allowed, ⛔ blocked by a rule, ✗ no route. The same table is added to the HTML/PDF report.

  • Blast radius — pick a device and ask "if this is compromised, what can it reach?": every reachable address and open service, with the findings a segmentation review would raise (management exposed to a camera VLAN, no filtering between segments, outbound Internet).

  • Scenario queue — queue several pings/probes and run them back to back on one warm network (later tests see the ARP/MAC tables and connections of earlier ones).

  • Playback — step or auto-play the event list at 0.5×–4×, filter it by protocol family (ARP, switching, routing, ICMP/L4, firewall/NAT), and inspect each step's PDU by OSI layer.

Policies — intent as tests (Simulate → ✓ Policies). State what must and must not be reachable ("Guest must NOT reach Management", "Staff must reach the NVR on tcp/554") and Plexus proves each one against the plan, naming the pair that breaks it. It does not test one convenient host per VLAN: probe addresses are placed inside and just outside every firewall rule that cuts through a subnet, so a rule covering only part of a VLAN is caught. Violated policies also show up as errors in the design review.

Labs (Simulate → 🎓 Labs). Guided scenarios — inter-VLAN routing, guest isolation, OSPF between two sites, surviving a cut uplink — graded by proving the result in the simulator, not by comparing config text. Any configuration that makes the network behave as asked passes.

The firewall is stateful: devices track the connections they let through, and a rule can match on it — access-list 130 permit ip any any established (IOS) or connection-state=established,related (RouterOS). That is what makes a one-directional policy possible ("Staff may reach Guest, Guest may not open connections to Staff").

Firewall rules can be scoped the way real gear does it: ip access-group <n> in|out on an interface (IOS) or in-interface= / out-interface= (RouterOS). An access-list bound nowhere stays device-wide. OSPF/RIP only advertise interfaces covered by a network statement (none at all = every interface); no router ospf turns the protocol off.

More of the network is modelled:

  • Spanning tree + redundant uplinks — give a switch a second uplink and STP blocks one link of the loop (root = lowest priority, then id); cut the active link and the backup takes over. show spanning-tree shows port roles.
  • DHCP server and relay — ip dhcp pool / /ip dhcp-server network, and ip helper-address / /ip dhcp-relay. Once any device configures DHCP, a client only gets a lease if its VLAN's gateway serves a pool for that subnet or relays to a device in the plan that does (with nothing configured, every VLAN with a subnet still hands out leases).
  • A console that remembers — the device console keeps the simulated network between commands, so ping followed by show arp, show mac address-table, show ip nat translations shows what was learned. Plus ? help, Tab completion, do, show interfaces, show access-lists, show ip protocols, a show running-config that includes everything configurable, and on RouterOS /export.

The RouterOS dialect is validated against real hardware (hAP ax lite, RouterOS 7.24.4).

From the plan to the device

Export ▾ → Device config / drift closes the loop between the drawing and the gear:

  1. Generate — pick a switch and get a RouterOS 7 script built from what the plan already holds: access ports with their VLAN, trunks, the VLAN table, the gateways an L3 switch hosts, its management address and static routes.
  2. Check drift — paste or upload the device's /export (on the desktop app: Pull from device reads it over SSH) and Plexus lists where it no longer matches the plan: a port on the wrong VLAN, a VLAN missing from a trunk, a gateway that isn't configured, VLAN filtering switched off — plus anything on the device the plan doesn't know about.

Safe default / intended use: the script is for review and for devices you manage. Plexus never guesses a physical trunk port — you assign it in the dialog, and an unassigned trunk is left out and flagged rather than assumed. Bridge VLAN filtering is enabled as the last command; apply from the console or in Safe Mode.

  1. Remediate — when the device has drifted, Plexus writes the script that brings it back: it adds or corrects only what the plan requires and removes nothing.

Pull from device (desktop, MikroTik) is read-only by construction: it runs ssh non-interactively with one fixed command (/export) chosen in the main process — the page cannot supply a command — uses key or agent authentication only, never prompts, and refuses a host key it has not seen (connect once with Connect via SSH first). It asks before every connection.

  1. Dry-run with rosconf (desktop) — hands the generated script (or the remediation script) to rosconf: Plexus writes it to its own data directory and opens a terminal running rosconf apply <host> -f <file>. That is a dry run: rosconf prints what it would send and changes nothing.

    Safe default, by construction: Plexus never passes --apply. Pushing configuration to a device is your own step — re-run the printed command with --apply added, after reading the dry-run output. The host, user, port and key go through the same validator as Connect via SSH, and the rosconf executable is chosen once through a native file dialog and stored in the app's own settings — a project file cannot name a program to run. Intended for devices you own or are authorised to configure.

Routers with WiFi

A router or gateway that has its own radio is placed with the switch/router tool, and Plexus gives it coverage like an access point: a wall-clipped ring, a share of the coverage percentage, and a place in the heatmap. The device panel shows Built-in WiFi with the standard, bands and planning range; untick it if the radio is switched off on site.

A MikroTik hAP ax³ placed as a router, with its coverage ring

Vendor Models with a radio Bands
Ubiquiti UniFi UDM / Dream Machine, Dream Router 2.4 + 5 GHz
Dream Router 7 2.4 + 5 + 6 GHz
MikroTik hAP mini, hAP lite, hAP, hAP ax lite, L009UiGS-2HaxD-IN 2.4 GHz
hAP ac lite, hAP ac², hAP ac³, hAP ax², hAP ax³, RB4011iGS+5HacQ2HnD-IN 2.4 + 5 GHz

Everything else in the router and switch catalogue (UDM-Pro/SE, Cloud Gateways, UXG, hEX, RB5009, CCR, every switch) is wired-only and gets no coverage. The table lives in files/src/routerWifi.js, checked against the vendors' spec pages; the range is a planning default (a desk-height router reaches a little less than a ceiling AP of the same class), not a measurement.

Desktop: project files

The desktop app has a File menu — New, New from Template, Open, Open Recent, Save, Save As — and the window title shows the file name, with a dot while there are unsaved changes. Save writes back to the file you opened. The page can only read or write files you picked in a system dialog (or that are in the recent list); nothing in a project file can name a path.

Client report, site templates, multi-floor coverage

Client report

  • Export ▾ → Client report — a document for the person paying for the network: predicted coverage per floor on the plan, on-site measurements where there are any, the equipment list, cabling and video-storage totals, and a sign-off block. It contains no IP or MAC addresses, VLANs, ports, internal notes or credentials (those stay in the technical PDF). Written in Greek when the project locale is el-*.
  • New from template… (empty state, or File menu) — starts a project with the VLAN plan, reachability policies and naming convention for a villa, a hotel or a restaurant. The "must never reach" policies fail until the firewall rules exist — that is the to-do list. No floor plan or APs: those are the site.
  • Other floors in the heatmap (Settings → Include other floors in heatmap) — APs on every other floor reach the current one through the slabs between: one slab loss per level and the true 3-D path length, using Floor-to-floor height. Floors are stacked in tab order and assumed to share a footprint.

The dialog also remembers the outcome of the last drift check per device ("matched the plan" / "N mismatches", with the time), saved with the project.


Tutorial 3 — Operate: connect to a real device

Goal: SSH into the physical device you clicked. Desktop app only.

  1. Give the device credentials. Select it → Credentials: set Protocol = SSH, Host (defaults to the device IP), Port, Username, and an optional SSH key path (e.g. ~/.ssh/id_ed25519). A 🔑 badge marks devices that are SSH-connectable.
  2. Protect the file. In Settings → Credentials passphrase, set a passphrase so credentials are encrypted at rest — a shared .plexus never leaks a password. (Entering Operate reminds you if plaintext passwords are present.)
  3. Connect. Switch to Operate (confirm the prompt), then right-click the device → Connect via SSH. Your OS terminal opens a live session.
flowchart LR
    RC["Right-click device"] --> M["Connect via SSH"]
    M --> T["sshConnect.js<br/>build {host,user,port,key}"]
    T --> P["preload bridge"]
    P --> V["main.cjs · sshArgv.cjs<br/>validate + rebuild argv"]
    V -->|valid| TERM["Terminal.app · gnome-terminal · Windows Terminal"]
    V -->|hostile input| X["❌ rejected (fail closed)"]
Loading

Security model. The renderer only ever sends structured fields — the main process re-validates them and rebuilds the ssh command itself, so a hostile project file can't inject a shell command. No password is ever put on the command line (key/agent auth, or ssh prompts in the terminal). The command run is exactly:

ssh -i ~/.ssh/your_key -p 22 admin@192.0.2.10

If a device connects as your local username instead of the one you expect, its Username field is empty — ssh falls back to your OS login. Set it.

Reaching devices over a VPN (WireGuard, OpenVPN)

Plexus does not create tunnels; it runs your system's ssh. So any VPN that is up on your computer works as it is: bring up the WireGuard or OpenVPN tunnel with its own client, set the device's Host to the address that is reachable through the tunnel (the device's LAN IP if the tunnel routes that subnet, or its tunnel address), and Connect via SSH, Pull from device and Dry-run with rosconf all go through it.

For a device behind a jump host instead of a VPN, add a Host block with ProxyJump to your SSH client config and use that alias as the device's Host — ssh resolves it; Plexus passes the name through unchanged.


Feature reference

Coverage modelling
  • Wall-aware coverage — per-material dB attenuation (drywall/wood/glass/brick/ concrete) summed along 72 cast rays per AP → the real reachable polygon.
  • Band-aware 2.4 / 5 / 6 GHz wall-loss multipliers; directional antennas (omni, ceiling, wall, sector 90/60/30°).
  • Real heatmap (Web Worker) — RSSI / SNR / SINR / MCS / throughput, band-filtered.
  • Channel widths 20–320 MHz (noise-floor + OFDMA-accurate); airtime/capacity checks.
  • Propagation models — log-distance, ITU-R P.1238, COST-231 multi-wall.
  • Regulatory regions (FCC/ETSI/JP/AU-NZ/IN/BR), roaming overlap, floor-to-floor leakage, auto channel/power/placement.
Network simulation (Packet-Tracer-class)
  • Deterministic forwarding engine: L2/VLAN/MAC, ARP, L3 routing (longest-prefix, TTL), ICMP ping/traceroute, L4 probe.
  • Inter-VLAN routing (L3 switch / SVIs / routed /30 uplinks).
  • Dynamic routing — OSPF (Dijkstra) and RIP (15-hop).
  • Services — DHCP, name-based DNS, NAT/PAT, ACL/firewall, internet cloud.
  • Device CLI — Cisco IOS + MikroTik RouterOS, running/startup config, show cmds.
  • Animated PDU on the map + step inspector; wireless association via real RF; fault injection.
Live operation (desktop)
  • Right-click → Connect via SSH (macOS/Linux/Windows terminal).
  • Per-device credentials + optional SSH key; encrypted credentials vault.
  • Fail-closed ssh-argv validation; no password on argv.
  • UniFi controller sync (pull as-built / push channel-power); live WiFi survey.
Devices · planning · organization · deliverables
  • Devices — AP/camera/switch catalogs (UniFi, MikroTik, Cisco, Aruba, Meraki, Hikvision, Dahua, Axis…), L2/L3 switches, wireless clients, walls, dead zones, SVG/DXF import, CV wall detection, DORI zones, NVR storage calculator.
  • Planning — PoE budgets, cable runs, topology tree, survey CSV import, Ekahau .esx interop, AP-on-stick.
  • Organization — inventory & rollout table, IPAM + VLAN registry, port maps, naming convention, as-designed-vs-as-built diff, handover pack.
  • Deliverables — branded PDF, BoM + cable-schedule CSV, per-AP install sheets, design-review comments, annotations, VLAN reachability matrix.
  • Plan → device — RouterOS 7 config generated per switch, and a drift check of a real /export against the plan.

Keyboard shortcuts

Key Tool Key Tool
A Add AP M Packet simulation
W Switch / Router K Wireless client
C Camera L Wall
D Dead zone N Annotation
R Ruler V Toggle coverage
H Toggle heatmap O Toggle overlaps
G Toggle grid ? Full cheatsheet

How it works (architecture)

The project model is compiled into a topology that a pure, headless engine forwards packets over; the UI is a thin renderer, and the CLI folds back into the same compile step so typed config changes what the next ping does.

flowchart TD
    subgraph Model
      P["Project model<br/>switches · APs · cameras · clients · VLANs"]
      CLI["CLI console<br/>cli.js (IOS / RouterOS)"]
    end
    P --> C["simCompile.js<br/>model → topology"]
    CLI --> C
    C --> N["sim.js · buildNet()<br/>forwarding engine"]
    subgraph ControlPlane["Routing control planes"]
      OSPF["ospf.js"]
      RIP["rip.js"]
    end
    OSPF --> N
    RIP --> N
    N --> EV["deterministic<br/>event stream"]
    EV --> UI["simUI.js<br/>animated PDU + inspector"]
    N --> WL["wireless.js<br/>best-AP association"]
Loading

Everything under files/src/ is pure and DOM-free, type-checked with tsc --checkJs (JSDoc, no .ts rename), and has a sibling test in tests/.


The coverage math

Coverage polygons — for each AP we cast 72 rays (every 5°). Each ray sums per-material dB loss × the AP's band factor (0.6 / 1.0 / 1.3 for 2.4 / 5 / 6 GHz) and shrinks its reach by 0.5^(loss/3) — every 3 dB of attenuation roughly halves range. The 72 endpoints form the cached coverage polygon.

Heatmap dBm — with a real-world Scale set, signal uses physical path loss:

RSSI(d) = EIRP − FSPL(1m) − 10·n·log₁₀(d) − Σ wall_dB
FSPL(1m) = 20·log₁₀(f_MHz) − 27.55        f = 2437 / 5500 / 6525 MHz
n        = 2.2 (log-distance) · 3.0 (ITU indoor) · 2.0 (COST-231 + per-wall)
EIRP     = Tx power + antenna gain − cable loss

See files/src/geometry.js (pure, unit-tested) and docs/accuracy.md for predicted-vs-measured.


Build & desktop installers

npm run build        # → dist/  (open dist/index.html directly; file:// safe)
npm run app:build    # → release/  (installer for the OS you're on)

base: './' keeps the web build portable across http://, a CDN, or file://. app:build only makes the current platform's installer; the GitHub Actions matrix (.github/workflows/release.yml) builds all three on a v* tag — one native runner per OS. App icons live in electron/resources/ (npm run make:icons, macOS only).


Tests

npm run verify       # the full gate: vitest + tsc
npm run e2e:install  # one-time: fetch the Playwright browser
npm run e2e          # Playwright end-to-end suite (web build, dev server)
npm run e2e:desktop  # builds, then drives the real Electron app (native bridge)

691 unit tests across 50 files — RF geometry (incl. the physical FSPL model), the forwarding engine (L2/L3, VLANs, ARP, routing, ACL, NAT, DHCP, DNS), OSPF and RIP convergence, the IOS/RouterOS CLI engine, the project→sim adapter (hardened against malformed/hostile project data), schema migration, crypto, the SSH argv validator (injection-rejection cases), and the bundled sample project. Also: structural validation of untrusted project files, the credentials vault, the RouterOS config generator and drift check, controller certificate pinning (against local self-signed HTTPS servers), property tests that check the IP math against a BigInt oracle across the whole address space, and a ratchet that fails on any unescaped interpolation into markup. Also unit-tested: the undo history, deferred image deletion, the credentials session (locked vaults survive a save), the project-file path gate and the rosconf dry-run argv (no --apply, hostile targets rejected). Plus a 5-test desktop E2E suite against the real Electron app — native Open / Save / Save As / Open Recent, the path gate from the renderer's side, and the rosconf hand-off — and a 29-test Playwright E2E suite (boot smoke + full scenario: load → place → wall → coverage re-clips → export → re-import, the inventory/rollout/handover flow, the simulation and device-config tooling, and security cases — hostile project fields stay inert, encrypted saves leak no credentials, share links ask first).


Project layout

files/
  index.html            UI shell
  app.js                App orchestrator (state, DOM, events, modes)
  styles.css            Theming + component styles
  src/
    geometry.js         Pure RF math (ray-cast, dBm, SNR, MCS, propagation)
    heatmap.js / heatmapWorker.js   Heatmap model + Web Worker
    network.js          IP / subnet / CIDR + IPAM helpers
    sim.js              Forwarding engine (L2/L3, ARP, routing, ACL, NAT, cloud)
    ospf.js / rip.js    Dynamic-routing control planes
    dns.js              Name-resolution zone
    cli.js / cliUI.js   IOS/RouterOS config engine + per-device console
    simCompile.js       Project model → engine topology
    simUI.js            Packet-sim panel + animated PDU
    wireless.js         RF → best-AP association bridge
    sshConnect.js       Device → ssh target/command (renderer)
    sshConfig.js        ~/.ssh/config parse + device matching
    constants.js        AP / camera / switch catalogs, patterns, PoE, regions
    migrate.js          Schema migrations (v1 → v11)
    imageStore.js / sampleProject.js / cameras.js / naming.js /
    dxf.js / esx.js / walldetect.js / zip.js / i18n.js / i18n/en.js
electron/
  main.cjs              Windows, UniFi sync, WiFi survey, SSH launch
  preload.cjs           contextIsolated bridge (window.plexusNative)
  sshArgv.cjs           Validated ssh-argv builder (shell-injection boundary)
tests/                  30 vitest suites + e2e/ (Playwright smoke + scenario)
.github/workflows/      ci.yml (verify) · release.yml (installer matrix on v* tags)
vite.config.js  vitest.config.js  playwright.config.js  tsconfig.json

Project file format

Projects save as a single JSON file; floor-plan images live in IndexedDB, referenced by id. Schema is versioned and the migrator reads every prior version — current schema is v11 (files/src/migrate.js). Device credentials are stored in the file only, excluded from Share links and reports, and encrypted when a project passphrase is set.


Roadmap

  • EIGRP and IPv6 in the simulator (today: static + OSPF + RIP, IPv4)
  • Embedded SSH console in Operate mode (today: launches the OS terminal)
  • Live state on the map from argus (link up/down, clients, PoE draw)
  • EtherChannel and HSRP/VRRP
  • Device config export for Cisco IOS and UniFi (today: RouterOS 7)
  • Ekahau / NetSpot survey-file import (today: CSV only)
  • Additional UI language bundles (English ships today)

Contributing

PRs welcome — see CONTRIBUTING.md. Anything touching geometry, the forwarding engine, the CLI, or schema versions needs a test in tests/.

Security

See SECURITY.md to report something privately. Credentials are never logged in plaintext; the SSH launcher validates all input and fails closed.

A project file, share link or autosave is treated as untrusted input: it is structurally validated on load, every field is escaped before it reaches markup, and the page's CSP allows no inline script. With a credentials passphrase set, a saved project contains no plaintext credentials anywhere (revision snapshots never carry them). The desktop app pins a UniFi controller's certificate on first use — you approve the fingerprint once, and a changed certificate stops the connection before any credential is sent.

License

MIT — do whatever you want, just don't blame me when your boss asks why the coverage map said the conference room had signal.

About

Plexus — cross-platform network site planner: WiFi + IP cameras + switches/PoE. Predictive wall-aware ray-cast coverage, SNR/throughput heatmaps, topology & cabling, branded PDF/BoM exports. Desktop apps for macOS/Windows/Linux, or runs offline in the browser.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

4 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages