MCP App Store
by KeenEthics
VARUA Remote Control icon

VARUA Remote Control MCP Server for ChatGPT

By VARUA

Overview

Connect ChatGPT and other MCP clients to computers you explicitly pair with VARUA Remote Control. Inspect and search files within locally authorized roots, review processes, and—when the machine owner enables them—write files, run bounded commands, and use persistent terminal sessions. Remote Control routes requests through outbound authenticated agents while mutation and execution permissions remain under local device control. Authorized filesystem roots constrain dedicated filesystem tools and command working directories; an approved command or terminal runs with the local agent user's OS permissions and is not an operating-system sandbox.

How to connect

  1. ChatGPT: Open the VARUA Remote Control listing in the ChatGPT app directory and choose Connect. ChatGPT listing VARUA Remote Control exposes 43 tools here.

Tools

account_usage

ChatGPT
Return current account-cycle usage and reset dates, effective calls remaining, plan limits, and the optional shared Free anti-abuse allowance. This introspection call is not itself metered.

activity_recent

ChatGPT
Return privacy-safe recent VARUA Remote Control operation metadata for recovery, optionally filtered by tool, device, or lower timestamp bound. Arguments, environment values, paths, and raw command output are never returned.

capabilities

ChatGPT
Describe VARUA Remote Control capabilities and their safety/metering metadata

device_health

ChatGPT
Ask a connected VARUA Remote Control agent for its health report

devices

ChatGPT
List registered devices and the capabilities each agent advertises

filesystem_copy

ChatGPT
Copy an authorized regular file or, with recursive=true, a bounded directory tree to a destination that must not already exist. Directory copies reject protected paths, symlinks, and unsupported entries.

filesystem_list

ChatGPT
List bounded entries in one authorized directory on a connected device

filesystem_mkdir

ChatGPT
Create a directory tree inside an authorized root

filesystem_move

ChatGPT
Move a path between authorized locations without overwriting the destination. Optional source hash/kind preconditions require a current VARUA Remote Control agent.

filesystem_patch

ChatGPT
Apply exact UTF-8 text edits only if the file still matches the SHA-256 returned by filesystem_read. All occurrence checks pass before replacement, and failed preconditions leave the original untouched.

filesystem_patch_many

ChatGPT
Apply SHA-256-guarded exact text edits across 1-32 authorized UTF-8 files. VARUA Remote Control validates every hash and occurrence precondition before mutating any file and rolls back already-swapped files if a commit step fails.

filesystem_read

ChatGPT
Read bounded UTF-8 file content from an authorized root. Supports 1-based line windows or tail reads and returns a SHA-256 for safe follow-up patching.

filesystem_read_many

ChatGPT
Read up to 32 authorized files in one logical call. Use paths for simple shared limits or files for per-file line/tail/byte ranges. Individual failures are isolated instead of failing the whole batch.

filesystem_remove

ChatGPT
Remove an authorized file, symlink, or directory. Recursive directory removal requires recursive=true, refuses allowed roots, preflights protected descendants, and supports optional hash/kind stale-state guards.

filesystem_stat

ChatGPT
Return rich metadata for one authorized path, including creation/modification times and, for regular files, SHA-256 plus UTF-8 line count when bounded

filesystem_write

ChatGPT
Rewrite or append bounded UTF-8 content inside an authorized root. Optional preconditions make creates and rewrites stale-safe; checked preconditions require a current VARUA Remote Control agent.

get_profile

ChatGPT
Return the VARUA Remote Control profile represented by the current authenticated credentials. The opaque id remains stable across token refresh, reconnection, and display-metadata changes.

health

ChatGPT
Report VARUA Remote Control gateway health

process_batch_status

ChatGPT
Return sanitized progress and child process handles for one managed process batch without reading child output. This control operation is quota-neutral.

process_batch_stop

ChatGPT
Cancel queued work and terminate active process trees in one managed process batch. This lifecycle-control operation is quota-neutral.

process_batch_wait

ChatGPT
Wait up to 10 seconds for a managed process batch to finish and return sanitized progress without reading child output. This control operation is quota-neutral.

process_info

ChatGPT
Inspect one process without exposing command-line arguments or environment variables

process_list

ChatGPT
List bounded process metadata without command-line arguments or environment variables

process_managed_list

ChatGPT
List VARUA Remote Control-managed long-running processes visible under the active security profile. Use this to recover process handles after a stream interruption or transient agent↔gateway reconnect. This control operation is quota-neutral.

process_read

ChatGPT
Wait for buffered output or completion from a managed process. Managed processes survive transient agent↔gateway reconnects. Output is retained in a bounded replay buffer: omit cursors for normal continuation, use cursor 0 after a stream/reconnect failure to replay retained output, or tail_bytes for the newest output. This is quota-neutral control traffic; use wait_ms instead of sleep polling.

process_run

ChatGPT
Run one short process expected to finish within 10 seconds. For long-running commands use process_start plus process_read with wait_ms; never use process_run sleep merely to wait.

process_run_many

ChatGPT
Start 1-16 independent managed commands, each with an explicit program and optional argument array, under one approved working directory. Bounded concurrency defaults to 4 and is capped at 8. Returns immediately with a stable batch id and child process handles. Child output remains in the normal replay-safe process buffers. Use a non-sensitive idempotency_key for retry safety after transport failures.

process_start

ChatGPT
Start a long-running managed process and return immediately with a stable process handle. Managed processes survive transient agent↔gateway reconnects. For retry safety after a transport failure, provide a non-sensitive idempotency_key; the same key and request returns the existing process instead of starting a duplicate. Prefer this for builds, tests, servers, and commands that may exceed 10 seconds.

process_status

ChatGPT
Return current status, exit code and elapsed time for one managed process without reading or advancing any output cursor. Managed processes survive transient agent↔gateway reconnects. This control operation is quota-neutral.

process_stop

ChatGPT
Stop and remove a managed process, returning its remaining bounded output. This control operation is quota-neutral.

process_wait

ChatGPT
Wait up to 10 seconds for a managed process to finish and return status, exit code and elapsed time without reading or advancing stdout/stderr cursors. Use this quota-neutral control call when only completion matters.

search_list

ChatGPT
List resumable search sessions visible under the active security profile. Use this after a stream or transient gateway reconnect to rediscover search handles. This recovery/control operation is quota-neutral.

search_read

ChatGPT
Wait for and read progressive results from an existing search. Search sessions survive transient agent↔gateway reconnects, so the same search_id can resume afterward. This control operation is quota-neutral; prefer wait_ms over polling loops.

search_start

ChatGPT
Start a resumable filename or content search under an authorized root and return a small first page when available. Git ignore rules are honored by default. Keep the returned search_id and continue with search_read only when more results are needed.

search_stop

ChatGPT
Stop an existing search without returning its accumulated results. This control operation is quota-neutral.

terminal_interact

ChatGPT
Write bounded input to a persistent terminal and wait for bounded output in the same call. Prefer this for REPLs and interactive shells instead of separate write/read chatter.

terminal_list

ChatGPT
List persistent shell sessions owned by a locally execution-approved agent. Shell sessions survive transient agent↔gateway reconnects; use this quota-neutral recovery call to rediscover session handles afterward.

terminal_read

ChatGPT
Read bounded retained output from a persistent shell session, optionally waiting up to 10 seconds. Shell sessions survive transient agent↔gateway reconnects. Omit cursor for normal continuation, use cursor 0 after a stream/reconnect failure to replay retained output, or tail_bytes for the newest output. Prefer wait_ms over separate sleep commands.

terminal_start

ChatGPT
Start a persistent shell session inside an approved working directory

terminal_stop

ChatGPT
Stop and remove a persistent shell session, returning its remaining buffered output

terminal_write

ChatGPT
Low-level write-only input to a persistent shell session. Prefer terminal_interact when you need output in the same operation.

work_context

ChatGPT
Summarize one authorized work location plus active VARUA Remote Control processes, searches, terminals rooted there and optional detected version-control context. This generic recovery tool does not return command arguments, environments, process output, or file contents.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/varua-remote-control"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/varua-remote-control)