Remotely

Remotely is a full‑stack, self‑hosted remote access platform that leverages the .NET ecosystem to provide real‑time control, scripting, and monitoring of Windows desktops. At its core, the application exposes a WebSocket‑based communication channel via SignalR Core, enabling low‑latency, bi‑directional data flow between a browser‑based dashboard and native client agents installed on target machines. The server side is an ASP.NET Core 7 web application that hosts both the UI (built with Blazor Server) and the API layer, while a lightweight C# client daemon runs on each managed device to relay input events and capture screen frames.

• Frameworks: ASP.NET Core 7, Blazor Server (for the interactive UI), SignalR Core for real‑time messaging.
• Languages: C# (full codebase), Razor syntax for Blazor components, minimal JavaScript for client‑side interactions.
• Database: SQLite is the default persistent store (Remotely.db), though the data layer is abstracted via Entity Framework Core, making migration to PostgreSQL or SQL Server straightforward.
• Containerization: A ready‑made Docker image (immybot/remotely) is available, with a docker-compose.yml that mounts /app/AppData to host storage. The architecture assumes a single‑instance deployment but can be horizontally scaled by running multiple server replicas behind a load balancer that preserves WebSocket connections.
• Reverse Proxy: The project ships with Caddy as the only officially supported reverse proxy, configured to forward the necessary X-Forwarded-* headers for HTTPS termination and client IP preservation. Custom proxy setups require manual header configuration in ASP.NET Core’s ForwardedHeadersOptions.

• Remote Control: Full keyboard, mouse, and clipboard mirroring via SignalR messages. The client exposes a COM‑like API that can be invoked from PowerShell or C# scripts to programmatically trigger sessions.
• Remote Scripting: A built‑in script engine (PowerShell, batch, or custom) allows agents to execute commands on the target machine and stream output back to the dashboard.
• Device Management: RESTful endpoints expose CRUD operations for devices, groups, and users. Authentication is handled via ASP.NET Identity with JWT tokens, enabling integration into existing IAM solutions.
• Webhooks & Events: The server emits events (session start, end, error) that can be consumed by external services. Developers can subscribe to these via the API or by configuring HTTP callbacks in the admin UI.
• Extensibility: The client exposes a plugin interface where additional modules (e.g., custom authentication, telemetry collectors) can be dropped into the Plugins folder and discovered at runtime.

• Self‑Hosting: Requires .NET 7 runtime (or Docker for convenience). The server writes all state to a single SQLite file, making backups trivial. For production workloads, the recommendation is to swap SQLite for PostgreSQL or SQL Server and configure connection strings via environment variables.
• Scalability: SignalR supports backplane options (Redis, Azure Service Bus). While the default Docker image uses in‑process messaging, developers can extend the Startup class to add a Redis backplane for multi‑node deployments.
• High Availability: By exposing the service through a load balancer that preserves WebSocket connections and by persisting Remotely.db to shared storage, the platform can be made highly available. Health checks are exposed on /healthz.

• SDKs: The client agent can be embedded into custom installers or managed via configuration files (appsettings.json). Developers can programmatically set the server URL, authentication tokens, and device metadata.
• Custom Plugins: The plugin system is intentionally minimal; any .NET assembly implementing a known interface (IRemotelyPlugin) will be loaded at runtime. This allows for adding telemetry, custom authentication providers, or even new UI components.
• Automation: The REST API and PowerShell cmdlets (Get-RemotelyDevice, Invoke-RemotelyScript) enable full automation of device provisioning, session initiation, and reporting.

• Enterprise IT Support: Deploy Remotely in a corporate network to provide on‑call support without exposing RDP or VPN. The single‑page Blazor UI offers session logging and audit trails.
• IoT Device Management: Run the lightweight agent on edge devices to monitor status, push updates, or execute diagnostic scripts remotely.
• DevOps Automation: Integrate with CI/CD pipelines to spin up test machines, run scripts, and capture logs before tearing down the environment.
• Education & Training: Provide remote lab access to students while keeping all traffic encrypted and logged within the organization.

• Open Source & Self‑Hosted: Full control over data, no vendor lock‑in, and the ability to audit every line of code.
• Modern .NET Stack: Familiar C# tooling, strong type safety, and rich ecosystem for unit testing and CI/CD.
• Low Footprint: The agent is a small console application (~2 MB) that runs as a service, making it suitable for high‑density deployments.
• Extensible API Layer: Well‑documented REST endpoints and