ShellYard
The integration is the product

Not a bundle.
An integration.

Anyone can put six tools in one window. ShellYard makes them share state — your active SSH session is a routable bastion for the HTTP client, a tunnel for the database inspector, and live context for Magellan. One audit log. One Space per client. Tools that work together, not just live together.

8

surfaces

8

connection types

6

DB engines

37

network tools

01 Remote access

Every protocol you use, in one tab strip.

All connection types live in the same window with the same auth model and the same audit trail. Tier only changes whether connections live in your Personal Space or are shared across team Spaces.

Protocols

  • SSH — Key + password auth, jump-host chains, agent forwarding.
  • Telnet — For legacy gear that still speaks it; same tab strip as everything else.
  • Serial / console — USB-to-serial dongle support with configurable baud rate and flow control.
  • RDP — Launches via the platform-native client — Microsoft RDP on macOS, mstsc on Windows.
  • VNC — Built-in VNC viewer with optional SSH-tunnel routing. Headless Linux, IoT panels, and lab gear pixel-for-pixel — no second tool needed. Free on every tier.
  • Embedded web browser — Full browser pane for switch / firewall / Cisco GUI workflows.
  • Local terminal — System shell — zsh / bash / cmd / pwsh — in the same tab system.
  • AWS SSM Session Manager — Managed-instance shell with no public IP and no SSH keys; auto-installs the session-manager-plugin on macOS and Windows.

Organization

  • Connection folders — Nested grouping with search across hosts, tags, and notes.
  • Quick Connect — Top-frame bar for one-shot ad-hoc SSH without saving a connection.
  • Vault auto-fill — Credentials drop into any session type — SSH, Telnet, RDP, Serial, SSM.
  • Recent connections — Most recently used hosts surface in the sidebar.
  • Right-click menu — Rename, duplicate, delete, or move connections inline.

Inside an SSH session

  • Health subtab — Every SSH tab has Terminal | Health. One round-trip pulls uname, uptime, free memory, disk by mount, failed units, recent journal lines into a card grid. Magellan-attach with Explain and Suggest-next-steps presets.
  • Container detection — Health spots Docker, LXC, kubepods, and Podman containers and shows a badge — explains why systemd panels are empty instead of looking broken.
  • SFTP right-click — View / Edit (5 MB cap, preserves mode), Diff against local, Permissions grid, Tail in Log Viewer, Download, Delete. Empty pane: New file / New folder / Refresh.
  • Active SSH on top — The HTTP client's Tunnel-via dropdown sorts active SSH sessions to the top; offline saved connections sink below for pre-binding.
02 Live tools

What's running, what's logging, what's tunneled.

Three operational panes that live alongside the connection list. Tunnel Manager is on every plan; Log Viewer and Docker Inspector unlock on Pro.

Tunnel Manager (Free)

  • Per-session cards — Every active SSH session as a card with host/user and its open local-port forwards underneath.
  • Inline + Local forward — localhost:N → bastion → target:M from a quick form. Blank port = auto-pick.
  • Close-X per forward — Tear down any forward with one click; refreshes every 5 seconds so other-window changes show up.

Log Viewer (Pro)

  • Three sources — Tail remote files (tail -F over SSH), system journals (journalctl -f, optionally -u <unit>), or local files. Same UX for all three.
  • Live filter + highlight — Regex narrows visible lines without stopping the stream; error / warn lines auto-highlight.
  • Pause / resume — UI pauses while the buffer keeps filling — no missed lines during the freeze. 5,000-line cap per tail keeps the renderer snappy.
  • Magellan-attach — Hands the last 200 visible lines (capped 50 KB) to a fresh Magellan chat for "what is this error pattern."
  • Honest closures — [tail closed: <reason>] surfaces when a stream dies — rotated file, dropped session, removed unit — instead of silently disappearing.

Docker Inspector (Pro)

  • Local or remote — Picker defaults to local Docker; every active SSH session also appears, re-targeting the daemon on switch.
  • Grouped by Compose project — docker compose ls + label scan — standalone containers fall into Ungrouped.
  • State-aware actions — Start / Stop / Restart / Pause appear only when the container state allows; no confusing greyed-out buttons.
  • Detail panel — Inspect (pretty-printed JSON) and Logs (live --follow) subtabs, both Magellan-attachable.
  • Scope is intentional — List, inspect, logs, exec — not Portainer. No image management, no swarm, no network/volume editing.
03 HTTP / GraphQL / Realtime

A Postman-class API client that knows your infrastructure.

A first-class HTTP, GraphQL, and Realtime client on the API rail. The differentiator is SSH-tunnel routing: any request can flow through an active SSH session, so internal-only APIs are reachable without manually staging port forwards.

Request builder

  • Methods — GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS.
  • Headers, params, path vars — Headers, query params, and path-variable substitution (`{id}`).
  • Body types — Raw text / JSON / XML / HTML, x-www-form-urlencoded, multipart (file + text fields), GraphQL, binary file.
  • Auth presets — None, basic, bearer, API key (header or query), OAuth2 (auth code, client credentials, password) with token refresh, digest, AWS Signature v4.
  • Pre/post scripts — Sandboxed JS pre-request and post-response scripts.
  • Tests block — Assertions on status, headers, and JSON body with a results panel.

Response viewer

  • Pretty-print — JSON, XML, HTML, image rendering inline.
  • Timing breakdown — DNS / TCP / TLS / request / response on every call.
  • Cookies tab — Per-domain cookie inspection.
  • Status code reference — Mouseover for the spec description.
  • Save response to file — Native save dialog from the response pane.

Collections + environments

  • Hierarchical folders — Collection → folders → requests, with rename / duplicate / move / delete.
  • Soft-delete + undo — Every mutation can be reverted from a brief undo banner.
  • Environments (per Space) — Variable substitution in URL, headers, params, body, and scripts. Secret-marked values are encrypted under the per-Space CMK on Team and Enterprise.

Collection Runner

  • Sequential or parallel — Run a collection or folder, with live progress streaming.
  • Aggregate report — Pass / fail counts and per-request timings.
  • Export report — JSON or Markdown.

Imports

  • Postman v2.1 — Drop in an exported Postman collection; structure preserved.
  • OpenAPI 3.x — YAML or JSON spec → collection skeleton with paths, params, auth.
  • cURL — Paste a `curl ...` command and it becomes a request.
  • HAR — Drop in a HAR file; every request becomes a saved entry.
  • Reverse export — Round-trip back to Postman v2.1.

Routing & sharing

  • SSH-tunnel routing — Pick any active SSH session — the request flows out the remote network instead of your local one.
  • Cross-Space sharing — Share collections across Spaces on Pro and above.

GraphQL

  • Query + variables editor — Side-by-side panes with prettify and run against any GraphQL endpoint.
  • Shared collection store — GraphQL requests live alongside REST requests.

Realtime — WebSocket / SSE / MQTT

  • WebSocket — Connect, send frames, watch frames stream in.
  • SSE (Server-Sent Events) — Subscribe and follow with auto-reconnect.
  • MQTT — Connect over TCP or TLS, subscribe with topic wildcards, publish at QoS 0/1/2 with retained-message awareness.

Webhook Receiver (Pro and above)

  • Local HTTP listener — Point a vendor or device callback at your laptop and watch the requests arrive in real time. The inbound complement to the outbound REST client.
  • LAN bind, optional — Default loopback; flip to 0.0.0.0 so a switch, IoT panel, or webhook source on another machine can reach the receiver across your network.
  • Capture buffer — 200 most recent requests with full method, headers, query, and body. 1 MiB body cap per request.
  • Attach to Magellan — Send the captured payload to Magellan with one click — useful when the vendor docs and the actual payload disagree.
04 Data Inspector

Six database engines. One workspace. SSH-tunneled.

Open any saved DB connection from the Data rail. Each engine has its own workspace — query editor, schema browser, Health dashboard, result export — but they share one shell so you can flip between engines without re-learning the UX.

Supported engines

  • PostgreSQL — Query editor, schema browser, smart JSON pretty-print. Free.
  • MySQL / MariaDB — Query editor, schema browser, engine-aware quoting. Pro and above.
  • Microsoft SQL Server — T-SQL editor with bracketed-identifier auto-quoting, schema browser, live Health dashboard. Pro and above.
  • SQLite — Open any .sqlite file — no server, no setup. Free included.
  • Redis — Command shell, per-key viewer, paginated key list with pattern filter.
  • MongoDB — Query editor (filter / projection / sort / limit), document viewer, collection browser.

Connection management

  • Per-Space, encrypted — Host, port, credentials, SSL mode, file path stored encrypted per Space.
  • SSH tunnel routing — Same SessionHandle pattern as the HTTP client — route DB traffic through any active SSH session.
  • Test-connection probe — Validates on save before the connection is added.

Query workspace (SQL)

  • Editor with ⌘↵ — Statement detection routes SELECT / WITH / VALUES / SHOW / EXPLAIN / TABLE to the row grid; everything else runs as exec.
  • Schema browser — Databases → schemas → tables / views, drill-down inline.
  • Engine-aware quoting — Postgres / SQLite double-quote, MySQL backtick, SQL Server bracket — `SELECT * FROM "FreeResponse"` works on mixed-case names.
  • Result grid — Row #, column types, JSON pretty-print for jsonb / array cells.
  • Audit logging — Every statement is logged (truncated at 4000 chars) and surfaces in the Audit Log.

Redis workspace

  • DB picker — 16 logical DBs.
  • Key list — SCAN-paginated with pattern filter.
  • Per-key viewer — Type, TTL, decoded value, delete.
  • Command shell — redis-cli style with structured reply rendering.

Mongo workspace

  • Database / collection tree — Drill-down navigation.
  • JSON spec editor — Filter / projection / sort / limit in JSON.
  • Document result viewer — Pretty-printed JSON with structured cell rendering.

Result export

  • Tabular results — CSV, TSV, JSON for SQL and Redis.
  • Document results — JSON array or NDJSON for Mongo.
  • Native save dialog — Excel-friendly CSV escaping; filenames are date-stamped.

Health dashboards (per engine)

  • Postgres — Version, uptime, role, connection pool, buffer cache hit %, commit/rollback ratio, top databases by size, active queries, replication health.
  • MySQL — Threads vs max connections, traffic counters, InnoDB buffer pool hit ratio, top schemas by size, running queries, replication status.
  • SQLite — File size, page geometry, fragmentation %, journal mode, per-table row counts, integrity check.
  • Redis — Client counts, memory vs max, hit ratio, persistence + replication state, keyspace breakdown, slowest commands.
  • MongoDB — Connections, op counters, cache hit ratio, replica-set state, per-database stats, currently running ops.
05 Network diagnostics

40+ tools you would otherwise scatter across a folder of utilities.

Every diagnostic surface ships its current output to Magellan with a single button. Same on every tier — this is the engineering surface the product is built around.

Discovery & probes

  • Host probe — ICMP / TCP / UDP probes with selectable ports.
  • Ping sweep — CIDR-aware, parallel ICMP.
  • Network discovery — Ping sweep + port scan + reverse DNS in one pass.
  • Port scanner — TCP connect or SYN where supported.
  • Nmap Scanner — Full Nmap integration with parsed XML output.
  • MTR — Pure-Go ICMP my-traceroute — continuous per-hop loss / latency, ASN annotation, reverse DNS, no system tools required.
  • DNS Tools — A/AAAA/MX/TXT/CNAME/PTR/SRV/CAA/DNSKEY/DS/TLSA, plus DKIM / DMARC / SPF presets, reverse lookup, and propagation across resolvers.
  • WHOIS / RDAP — RDAP first (ARIN bootstrap follows referrals to RIPE / APNIC / LACNIC / AFRINIC), classic port-43 fallback.
  • NTP Tester — Stratum, offset, jitter, root delay / dispersion, leap indicator, reference clock.
  • Bandwidth Monitor — Real-time interface throughput graph (in / out Mbps).
  • DHCP Browser — Query DHCP leases, find IPs by MAC, scope utilization via SNMP.
  • Syslog Viewer — Live UDP listener with severity filtering and export.
  • AP Scanner — Nearby Wi-Fi APs with SSID / BSSID / channel / band / RSSI / security. Uses macOS airport, Linux nmcli, Windows netsh.

Capture & analysis

  • Packet Capture — Per-interface filter, save to PCAP for Wireshark.
  • TLS Inspector — Full chain with key sizes + signature algorithms, protocol versions (1.0–1.3), accepted cipher suites with strength, OCSP stapling, HSTS, ALPN, graded findings.
  • Cert Checker — Date / chain / SAN validation.
  • File Transfer — TFTP / FTP / SFTP under one tool.

Encoding & data

  • Encoders & Decoders — base64 / base32 / hex / URL / HTML / Unicode escape; epoch ↔ ISO timestamp; MD5 / SHA-1 / SHA-256 / SHA-512 hashing; UUID v4 / v7 generator.
  • JWT verify + sign — Full JWT lifecycle — decode with claim annotations, verify against HMAC / RSA / ECDSA / PSS keys, and mint fresh tokens. Expiry and validity windows broken down even when the signature fails. Free on every tier.
  • JSON / YAML — Pretty / minify / convert + structural diff (key-order- and whitespace-insensitive).
  • MAC Tracker — OUI vendor lookup + find a MAC across the saved switch fleet via SSH (Cisco IOS / NX-OS, Aruba AOS-CX / AOS-S, Juniper).
  • Subnet Calculator — CIDR math, VLSM allocator, subnet splitter, supernet summarizer; binary + hex breakouts.
  • PoE Budget Calculator — Pick a switch, drop in cameras / APs / phones or pull live wattage from PoE-MIB; color-coded per-port headroom.
  • Cron Calculator — Validate a cron expression and preview next firings (5-field, 6-field with seconds, @yearly / @monthly / …); IANA timezone aware.

Identity & certificates (Pro and above)

  • Cert Toolkit — Local PEM lifecycle in one tab — generate RSA / ECDSA keys, build CSRs, self-sign certificates, sign CSRs with your own CA, and inspect any PEM. Pure local; the private key never leaves the machine, no web tool involved.
  • AAA Tester — PAP, EAP-MD5, EAP-PEAP/MS-CHAPv2, and EAP-TLS — the four real-world enterprise AAA methods, in one tool. Probes TACACS+ and RADIUS; reports Accept / Reject / server-message / round-trip so you can isolate which side of the AAA chain is failing.

Device-side

  • SNMP Browser — v1 / v2c / v3, GET / WALK, with shared MIB uploads.
  • Active Directory Browser — Search users / groups / OUs, unlock accounts, check group membership.
  • Bulk Command — Run one command across many hosts.
  • Batch SSH — Parallel SSH execution with structured per-host results.
  • Config Backup — Pull configs over SSH and store with version history.
  • Config Diff — Between versions or between devices, side-by-side.
06 Documents, IPAM, and Spaces

Documentation that lives where the work happens.

Spaces are isolation boundaries on every tier — each one has its own data, audit log, and (on Team and Enterprise) its own KMS key. Documents and IPAM themselves are a Team-and-above feature — runbooks, notes, incident reports, host inventories, network overviews, and IPAM records live inside the same Space as the connections, credentials, diagnostics, and tool output. Free uses Spaces for organization without the documentation layer.

Spaces

  • Personal Space — Always private to the user, never synced to teammates.
  • Shared Spaces — Multi-user collaboration on Pro (1 max), Team (up to 25), and Enterprise (unlimited).
  • Per-Space audit trail — Every credential access, document edit, command run, HTTP request, DB query, and Magellan invocation is logged with actor / action / target / timestamp.
  • Space switcher — Top-bar control flips the entire workspace context.
  • Space Management — List view of members, roles, and storage usage.

Documents (Team and Enterprise)

  • Document kinds — Note (blue), Runbook (amber), IPAM subnet (emerald), Incident Report (rose) — kind-aware glyphs in the tab strip and starter templates per kind. Use it for documentation, not as a ticketing replacement.
  • Incident Report scaffold — Capture what happened, what was checked, what changed, and how it was resolved. Timeline, evidence sections (terminal output, HTTP response, DB query, log snippets, config diff), root cause, resolution, follow-ups, customer-facing summary.
  • Folder tree — Collapsible tree in the Docs launcher — top-level folders as sections, nested folders indented, a Root section for folder-less docs. Search / kind-filter falls back to a flat list.
  • IPAM (subnets + hosts) — Inline subnet calculator integration.
  • Version history — 90 days on Team; unlimited on Enterprise (subject to per-Space byte cap).
  • PDF export — Render any document to PDF.
  • Public share links — share.shellyard.com — optional password gate, configurable expiry, revoke any time, view-count tracking.
  • Live cloud resync — Active scope re-pulls on focus and every 30 s while focused (paused when blurred, 5 s debounce). Worst-case ~30 s lag for a teammate's edit. Background pulls skip the audit log.
  • Doc + Space caps — Team: 5 MiB / doc, 1 GiB / Space. Enterprise: 10 MiB / doc, 5 GiB / Space.

Importers (Team and Enterprise)

  • IT Glue — Documents and IPAM imported from your IT Glue account.
  • Hudu — Documents and IPAM imported from your Hudu account.

Team and Enterprise (shared crypto)

  • Per-Space customer-managed KMS — Each Shared Space gets its own AWS CMK; credentials shared into a Space are decryptable only by Space members.
  • Group-scoped credentials — Narrow decrypt access to a subset of Space members via Group DEKs. Removing a member rotates the Group key; even Space admins outside the Group cannot decrypt.
  • Cross-Space credential moves — Move a credential between Spaces or Groups in one click — the row is re-encrypted under the destination key and the source is wiped. No copies.
  • Cryptographic erasure — Offboarding a Space schedules its CMK for deletion; once the AWS pending window expires, all data under that Space is unrecoverable.

Enterprise-only additions

  • Per-Space audit-log filtering — Filter and export audit history per Space — useful for client reports and compliance reviews.
  • Larger storage caps — 10 MiB / document, 5 GiB / Space, unlimited version retention.
  • Procurement and contracts — Custom annual contracts, security review under NDA, priority email support.
07 Magellan AI

Every tool's output, one click away from AI.

Magellan is multi-provider and Space-scoped. AI context is what you select — never an autonomous read of the screen. Operators always run the command; Magellan never executes autonomously.

Magellan — ShellYard's AI assistant

Bring your own key

  • Anthropic Claude Anthropic
  • OpenAI OpenAI
  • Google Gemini Google Gemini
  • Ollama Ollama / OpenAI-compatible

Providers (BYO key)

  • Anthropic — Bring your Claude API key; choose model per Space.
  • OpenAI — Bring your GPT API key.
  • Google Gemini — Bring your AI Studio key; pick a Gemini model per Space.
  • OpenAI-compatible — Point at Ollama, LM Studio, OpenRouter, or any OpenAI-API-compatible endpoint.

Universal context attachment

  • "Ask Magellan" everywhere — Every tool — terminal, HTTP response, DB result, packet capture, SNMP walk, MTR trace, Redis key, Mongo doc — has a button that ships its current output as context.
  • Visible attachment — The chat shows an "Attached: <tool> · <size>" pill before send so there is no ambiguity about what the model received.
  • Per-tool prompt presets — "Channel congestion", "Rogue AP screen", "Spot anomalies", "Capacity check", and others, depending on tool.

Five-stage flow

  • Explain — Read what you shared and tell you what it means.
  • Suggest — Recommend the next diagnostic step or remediation.
  • Draft — Write the command, script, or runbook entry.
  • Review — You read the draft, edit if needed.
  • Execute — You run it. Magellan does not autonomously execute.
08 Vault and audit

Credentials in the vault. Actions in the audit trail.

Every tier ships the same vault UI. Storage and key model differ by plan. Free keeps an AES-256-GCM SQLite vault on the device with the master key in your OS keychain — nothing syncs. Pro syncs Personal credentials and HTTP environment secrets to DynamoDB, envelope-encrypted with AWS KMS in our account; the wrapping context binds each row to your Cognito identity so kms:Decrypt fails for any other user. Team and Enterprise add a dedicated customer-managed KMS key per Shared Space — credentials shared into a Space are wrapped with that Space's CMK, and KMS authorization gates Decrypt by Space membership, plus Group DEKs to narrow further. Enterprise crypto is identical to Team; the difference is audit-export filtering, retention, and procurement features. Not zero-knowledge — the KMS keys live in our AWS account. Audit log export ships on Team and above.

Vault

  • Per-credential metadata — Host, port, type, notes, tags.
  • Auto-fill across the app — SSH / Telnet / RDP / Serial / SSM, HTTP collection environments, database connections.
  • Personal vault — Always under the user's own key, regardless of tier.
  • Tag and search — Find credentials by metadata across saved entries.

Audit log

  • Searchable + filterable — By actor, action, target.
  • CSV export — Available on Team and Enterprise.
  • Per-Space trail — Each Space has its own log; useful for MSP client reporting.
  • Coverage — Surfaces every DB query (truncated to 4000 chars), every HTTP request, every Magellan invocation, every command run, every credential access.
09 Multi-window architecture

Process per window. Same store. Same session.

Each "New Window" launches a fresh ShellYard process bound to the same SQLite store and a localhost peer registry. SQLite WAL mode + busy_timeout makes cross-process reads and writes safe; auth + sync state are shared so a new window doesn't re-prompt sign-in.

  • ⌘N to spawn — New-Window button or keyboard shortcut spawns a peer process.
  • Encrypted auth handoff — One-shot Cognito refresh-token handoff via a 60-second temp file — the new window inherits the session without a sign-in prompt.
  • Send-tab-to-window — Right-click a tab and move it to another window.
  • Workspace-aware peers — A `live_processes` table broadcasts changes — rename a connection in window A and window B refreshes.
  • Cloud-resource sync broadcast — Cloud sync events propagate across all peer windows on the same channel.
  • Per-window ID — Each window has its own ID, surfaced in the title bar and audit log entries.

Open one app. Keep it open.

Free for solo evaluation. Pro for individual operators. Team for shared client work. Enterprise for per-tenant isolation.

Download free View pricing