local-runtime-mcp
Health Pass
- License — License: AGPL-3.0
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Community trust — 21 GitHub stars
Code Fail
- spawnSync — Synchronous process spawning in browser-extension/scripts/pack-sdk.mjs
- process.env — Environment variable access in browser-extension/scripts/pack-sdk.mjs
- network request — Outbound network request in browser-extension/src/service_worker.ts
Permissions Pass
- Permissions — No dangerous permissions requested
No AI report is available for this listing yet.
Portable MCP runtime with 21 tools for processes, files, images, Chromium profiles and Windows desktop control. Shared OpenAI and Cloudflare connections with owner-approved OAuth.
Local Runtime MCP
English · 简体中文
Give AI clients the programs, files, images, browser profiles, and desktop of the machine running lrmcp. Local Runtime MCP is a portable local runtime with 22 built-in MCP tools and reusable webpage capabilities registered from the file tree.
The same runtime offers an exact-origin-authorized browser SDK and a local model API with a separate model-only key. A browser model uses registered start / read / stop capabilities; Harness and applications keep their own agent loops. See tools, webpages and models.
Connect locally over stdio or Streamable HTTP, or remotely through OpenAI Secure MCP Tunnel and Cloudflare Tunnel. One running instance can expose both tunnels at once, with one set of process sessions, browser instances, and desktop control. Independent process sessions and browser tabs run concurrently; shared files and desktop input have explicit coordination rules.
- Native multimodal results. Files, browser pages, and desktop observations return text and MCP image content directly.
- Explicit browser targets. Connect several Chromium profiles, select a named browser instance, and operate its opaque tab handles.
- Desktop control that leaves you working. See every display and window, read UI Automation trees with their text, and operate controls through their patterns without the pointer, keyboard or focus. Physical input, when needed, borrows them under a token, shown by a small pill you can click to stop.
- Portable configuration. Keep
local-runtime-mcp.yaml, the executable, and browser integration together on a fixed or removable drive. - Independent connection providers. Enable OpenAI, Cloudflare, or both for the same Runtime Host. Public HTTP supports static Bearer credentials or OAuth authorization with owner approval.
- Platform-specific engines. Go hosts the runtime and MCP adapters; Rust implements Windows capture, UI Automation, and input; TypeScript implements Chromium integration.
Architecture
The connection layer delivers MCP requests. The capability layer defines machine operations. One Runtime Host owns the resources shared by every enabled entry point and client of a running instance.
flowchart TB
Operator[Operator] --> CLI[CLI + configuration]
CLI --> Supervisor[Entry-point supervisor]
Supervisor --> Host[One Runtime Host]
Local[Local MCP client] --> Stdio[MCP stdio]
Local --> Public[Public-facing HTTP origin · Bearer or OAuth]
Remote[Remote AI clients] --> OpenAI[OpenAI Tunnel adapter]
Remote --> Cloudflare[Cloudflare adapter + cloudflared]
OpenAI --> Private[Private HTTP origin · runtime credential]
Cloudflare --> Public
Stdio --> MCP[MCP adapter · 22 tools]
Private --> MCP
Public --> MCP
MCP --> Process[Process]
MCP --> Files[Filesystem]
MCP --> Image[Image]
MCP --> Computer[Computer]
MCP --> Browser[Browser]
Process --> Machine[Machine processes + files]
Files --> Machine
Image --> Machine
Computer --> Native[Rust Windows engine]
Native --> Desktop[Interactive desktop]
Browser --> Bridge[Authenticated loopback bridge]
Bridge --> Profiles[Chromium profile extensions]
Profiles --> CDP[CDP tabs + frames]
Host -. resource lifetime .-> MCP
Host -. owns .-> Process
Host -. owns .-> Files
Host -. owns .-> Computer
Host -. owns .-> Bridge
Supervisor -. owns provider lifetime .-> OpenAI
Supervisor -. owns provider lifetime .-> Cloudflare
Solid arrows show request flow; dotted arrows show lifetime ownership. Text and images travel as MCP content. OpenAI's private origin and the public-facing HTTP origin publish the same MCP Server while retaining their respective authentication boundaries. Cloudflare reaches the public origin over loopback; its external URL uses HTTPS.
| Layer | Responsibility |
|---|---|
| CLI and configuration | Select entry points explicitly and resolve configuration once. |
| Entry-point supervisor | Own provider lifetimes, report exits, and keep surviving entry points available. |
| Connection adapters | Deliver requests through stdio, HTTP, or a tunnel provider to the shared Server. |
| MCP adapter | Publish tool schemas, validate inputs, and encode results. |
| Capability services | Define resource identities, observations, actions, and concurrency. |
| Platform backends | Execute OS operations, Windows native interaction, and Chromium CDP commands. |
The Host creates one Process Manager, Filesystem Service, Browser Bridge, and Computer Controller. A provider failure affects that entry point; the Host and other live entry points continue. When all entry points finish, or the operator interrupts the runtime, shutdown stops admission, cancels pending work, cleans up managed processes and input, and closes listeners and helpers. Individual request failures retain the running Host and its other resources. Recovery restores connectivity without replaying machine actions.
Commands and transports
lrmcp
├── serve
│ ├── --transport stdio|http
│ └── --tunnel openai|cloudflare (repeatable with HTTP)
├── setup
│ ├── browser
│ └── oauth
├── version
└── help
serve starts one Host. Select --transport stdio for local process pipes or --transport http for HTTP connectivity. With HTTP, repeat --tunnel to enable both providers. Saved credentials configure a provider; the command selects whether it runs.
| Command | Connection and credentials |
|---|---|
lrmcp serve --transport stdio |
Standard MCP process pipes; the parent process supplies access. |
lrmcp serve --transport http |
Direct loopback Streamable HTTP using the configured public-client authentication mode. |
lrmcp serve --transport http --tunnel openai |
Official OpenAI forwarding to a private loopback MCP endpoint; configure the tunnel ID and API key. |
lrmcp serve --transport http --tunnel cloudflare |
Official cloudflared companion forwards to authenticated loopback HTTP. |
lrmcp serve --transport http --tunnel openai --tunnel cloudflare |
Both providers reach the same Host and resources. |
lrmcp setup browser |
Generate bridge credentials and extract/configure the extension. |
lrmcp setup oauth --client-name NAME --redirect-uri URI |
Register an OAuth client with its exact callback URI and generate credentials. |
lrmcp setup oauth --show |
Display existing OAuth credentials deliberately in the local terminal. |
lrmcp version |
Print the executable version. |
lrmcp help |
Show commands and flags. |
OpenAI starts its private endpoint on a dynamically assigned loopback port and uses a fresh, in-memory private-hop credential. Cloudflare uses the configured public-facing loopback origin and its maintained companion executable. Domain services remain independent of either provider. A second machine runs its own Host and uses a distinct connection address; independent machines have independent resources and handles.
Configuration
flowchart LR
Defaults[Defaults] --> YAML[Adjacent YAML]
YAML --> Environment[Environment overrides]
Environment --> Flags[Command-line overrides]
Flags --> Config[Resolved configuration]
Config --> Connection[Connection adapter]
Config --> Host[Runtime Host]
Precedence is command line > environment > YAML > defaults. The file path is always <lrmcp directory>/local-runtime-mcp.yaml. Configuration validation covers the components selected for this invocation. Browser instance identity belongs to each browser profile's extension storage; process, tab, and desktop observation handles belong to the current runtime lifecycle.
Capability domains
| Domain | Tools |
|---|---|
| Process | 2 |
| Filesystem | 6 |
| Image | 1 |
| Computer | 5 |
| Browser | 8 |
| Total | 22 |
Process · 2 tools
flowchart TB
Run[process_run] --> Resolve[Resolve program using child PATH]
Resolve --> Launch[Direct launch · pipe or PTY]
Launch --> Final[Completed result]
Launch --> Sessions[Independent process sessions]
Sessions --> Continue[process_continue · session_id]
Continue --> Input[Serialized stdin + PTY resize]
Continue --> Output[Bounded output · cursor read + wait]
Output --> Cursor[Received output_cursor → next read]
Sessions --> Retain[Completed async result · up to 10 minutes]
Continue --> Stop[Independent terminate path]
process_runacceptsprogram, argument array, working directory, environment overrides, initial stdin, execution timeout, output limits, and pipe or PTY I/O.process_continuereads retained output from explicit byte offsets, writes stdin, closes pipe input, resizes a PTY, waits, or terminates a managed session.
Bare program names use the merged child PATH in both I/O modes; Windows also uses PATHEXT. Explicit relative executable paths resolve against the requested working directory. To execute shell syntax, launch the desired shell explicitly with its arguments.
Different sessions run concurrently. Within one session, input writes are serialized and output reads preserve the bounded stdout and stderr buffers. Waiting for output leaves termination available, including when stdin is blocked. Output and queued input are bounded; a single stdin payload is limited to 16 MiB.
Each result includes output_cursor: {stdout, stderr} with the next byte offsets. Pass the last successfully received cursor to process_continue to collect only new output. Omitting the cursor starts at zero and rereads the retained output. The returned stdout_offset and stderr_offset identify the actual start of each stream; a truncation flag indicates that the requested prefix has aged out of its buffer. Completed asynchronous sessions remain readable for up to ten minutes. Under capacity pressure, the oldest completed session makes room for a new process; active sessions keep their place.
If a pure-read response is lost, repeat process_continue with the same session_id and cursor. The response can include output produced since the previous attempt. Advance the cursor and append output only after receiving a successful result. Calls that start a process or change stdin, PTY size, or process lifetime require checking the resource before retrying after an uncertain response. A lost initial launch response may leave the client without a session ID.
duration_ms is elapsed process time while the program runs and its fixed lifetime after exit. Collecting a completed session later leaves that duration unchanged.
Cancellation delivered to process_run before it returns a live session terminates and collects that process. Cancellation delivered to process_continue stops that call's wait; use terminate=true to end the session. HTTP disconnect cancellation follows the negotiated MCP protocol: SDK request-context propagation applies to protocol 2026-07-28 and newer; older stateless requests may finish their bounded wait after the client disconnects. Execution timeout and Host shutdown terminate managed processes independently of the MCP request deadline.
Filesystem · 6 tools
flowchart TB
Read[List · stat · read · search] --> Files[Machine filesystem]
Write[Create · replace · patch] --> Path[Resolve commit path identity]
Path --> Lock[Per-path commit coordination]
Lock --> Version[Read and verify expected SHA-256]
Version --> Build[Build complete new content]
Build --> Commit[Atomic publish]
Commit --> Files
| Tool | Operation |
|---|---|
filesystem_list |
Bounded directory traversal. |
filesystem_stat |
File metadata and optional SHA-256. |
filesystem_read_text |
UTF-8 line ranges with byte and line limits. |
filesystem_search_text |
Literal text or Go-regexp search. |
filesystem_write_text |
Explicit mode=create or mode=replace. |
filesystem_patch_text |
Version-checked, uniquely anchored contextual hunks. |
create publishes a complete file only if the destination is absent. replace requires an existing file and expected_sha256. Patches also require the expected hash and resolve all hunks against one immutable source version.
Text reads return complete lines. When the first selected line exceeds the byte budget, the call returns a bounded error; after earlier complete lines it reports truncation and the next line. Skipped lines are scanned with bounded memory, and requested SHA-256 values cover the entire file through streaming reads.
The Filesystem Service holds one path's commit lock from version validation through publication. Different paths and read operations remain concurrent. Final-component symbolic links are rejected for mutation; existing parent aliases are normalized for coordination.
These locks coordinate calls made through this Host. External editors and invoked programs retain their own access to the filesystem. Concurrent coding tasks can use separate Git worktrees to separate indexes and build outputs.
Image · 1 tool
flowchart LR
Read[image_read] --> Open[Open source once]
Open --> Bytes[Bound actual bytes read]
Bytes --> Header[Validate format + pixels + dimensions]
Header --> Original[Original encoded image]
Header --> Transform[Memory-bounded crop + resize]
Transform --> Encode[Byte-bounded PNG encoding]
Original --> Result[MCP image + metadata]
Encode --> Result
image_read supports PNG, JPEG, GIF, and WebP, returning native MCP image content with actual source bytes and dimensions. Optional crop and proportional resize produce PNG output. Encoded reads, pixel counts, dimensions, decoded transformation memory, and output encoding are bounded. Capacity waits respect request cancellation.
Image reading is stateless. Browser and Computer captures carry their own observation identities and coordinate semantics.
Computer · 5 tools
flowchart TB
Targets[computer_targets] --> Worker[Rust native engine]
State[computer_state] --> Worker
Wait[computer_wait · polls computer_state] --> Worker
Action[computer_action] --> Kind{kind}
Kind -->|semantic · place| Worker
Kind -->|physical input| Control[computer_control token + Go Desktop Coordinator]
Control --> Worker
Worker --> Displays[Displays · per-monitor scale]
Worker --> Capture[Windows Graphics Capture · covered windows too]
Worker --> UIA[UI Automation · one cached tree request · patterns]
Worker --> Input[Physical input + release cleanup]
Worker --> Pill[Bottom-of-display pill · Stop]
Pill -. revoke control .-> Control
The person at the computer keeps working while an agent does. Observation, waiting, semantic actions and window placement never touch the pointer, the keyboard or the foreground window; only physical input borrows them.
computer_targets(process="StuDev") → displays + windows (target_id)
computer_state(target_id=..., image=false, automation_id="map") → ref_id
computer_action(kind="invoke", element_ref=...) # no control, no focus change
computer_wait(target_id=..., name="搜地点", until="present") → fresh ref_ids
computer_state(target_id=...) → pixels of the window even while it is covered
computer_action(kind="place", target_id=..., bounds={...}) # resize without activating
computer_targetsreturns every display (ID, bounds, work area, scale, primary) and the visible top-level windows: opaque target ID, process, title, class, visible frame without the invisible resize borders, normal/minimized/maximized state and display. Cloaked windows are left out. Filter bypid,titleorprocess.computer_stateobserves one window, one display or every display. Windows are captured through Windows Graphics Capture, so a window covered by others, including GPU swap-chain content, is captured as it is drawn. For a window it also returns the UI Automation tree, fetched in one cached cross-process request: role, name (text included), AutomationId, class, value or toggle/selection/expansion state, bounds, depth and parent, disabled/offscreen/focused, and the supported patterns.elementschooses all, interactive or none;name,automation_idandrolefilter;max_elementsandoffsetpage.regioncrops,image=falseskips pixels,cursor=truedraws the pointer.computer_waitpolls a window's tree without pixels until an element matchingname,automation_idorroleis present or absent, then returns that observation and whether the condition was met.computer_actionsemantic kinds operate an element byelement_refthrough its pattern:invoke,toggle,select,expand,collapse,set_value,scroll_into_view,scroll_by(pages).placemoves or resizes a window to a visible frame and restores or minimizes it without activating it, across displays of different scale. Physical kinds,activate,move,click,double_click,drag,type_text,press_keyandscroll, needcontrol_idand a state observed with it.computer_controlallocates the single pointer and keyboard to one workflow. It has a five-minute idle expiry refreshed by controlled operations; release, expiry, local Stop and shutdown cancel pending work, clear injected input and invalidate actionable observations.
Refs are verified against the element's runtime identity at use, so a ref whose control was replaced fails instead of acting on something else. Physical actions invalidate prior states; semantic actions keep them. Coordinates are relative to an observation's origin, which is in physical virtual-desktop pixels; displays to the left of the primary have negative origins.
While physical control is held, a small translucent pill at the bottom of the display being worked on reads “AI 正在操作 · 点此停止”; clicking it revokes control. It never outlines windows, never takes focus, and is excluded from capture. Nothing is drawn for semantic actions.
Browser · 8 tools
flowchart TB
Tools[Browser tools] --> Registry[Instance registry + tab routing]
Registry --> Bridge[Authenticated loopback bridge]
Bridge <-->|WebSocket · commands + keepalive| Edge[Edge profile extension]
Bridge <-->|WebSocket · commands + keepalive| Chrome[Chrome profile extension]
Edge -->|HTTP · results + authorization| Bridge
Chrome -->|HTTP · results + authorization| Bridge
Chrome --> Intake[Command intake]
Intake --> Queue[Bounded per-tab FIFO scheduler]
Queue --> TabA[Tab A · CDP frames]
Queue --> TabB[Tab B · CDP frames]
TabA --> Observation[Document epoch + snapshots + screenshot space]
TabB --> Observation
Install the same MV3 extension in each intended Chromium profile. Give each instance a readable label in extension options, such as Edge · Work or Chrome · Research. The extension keeps a stable UUID in that profile and connects to the shared bridge using its token. chrome.debugger sends CDP operations directly to tabs and frames.
Each profile receives commands over one authenticated loopback WebSocket and exchanges keepalive messages every 20 seconds. A browser alarm restores interrupted connections. Results and desktop-operation authorization use authenticated HTTP on the same bridge. This connection remains active while browser tasks are idle, following Chromium's extension service-worker WebSocket lifecycle.
| Tool | Target and operation |
|---|---|
browser_status |
List named browser instances and their connection health. |
browser_tabs |
Select browser_id and discover tabs. |
browser_open |
Select browser_id; open a tab, with active=false by default. |
browser_close |
Close an opaque tab_id. |
browser_navigate |
URL, back, forward, or reload for tab_id. |
browser_snapshot |
Bounded accessibility text and versioned element refs across frames. |
browser_screenshot |
Viewport, full-page, or clipped PNG for tab_id. |
browser_action |
Ref- or screenshot-targeted input, forms, files, dialogs, and JavaScript evaluation. |
Copy browser_id from status and the opaque tab id from discovery or creation into subsequent tab_id arguments. The tab handle includes its instance and lifecycle identity internally; callers treat it as an opaque string. A missing or offline target returns an error, preserving the selected profile. After extension worker restart or reconnect generation change, discover tabs again and acquire fresh observations.
Actions include click, double_click, hover, drag, type_text, set_value, press_key, scroll, select, check, upload_files, handle_dialog, and evaluate. Viewport coordinate actions require the matching screenshot ID. Element references belong to the observed document/frame generation; navigation, frame changes, reconnects, and side effects invalidate observations.
Different browser instances and tabs execute concurrently. Operations on one tab are serialized. Queue capacity and execution slots are bounded, and canceled queued work is discarded. Profiles keep their own browser data; tabs in one profile share that profile's sessions, cookies, and accounts.
Browser operations that change the visible desktop coordinate with Computer control. Background tab work remains independent; when a visible operation conflicts with an owned desktop, supply the matching control_id or wait until control is released.
Concurrent workflows
| Resource | Coordination |
|---|---|
| Process | Independent sessions; ordered input and replayable cursor reads within retained output. |
| Filesystem | Parallel reads and different paths; serialized version-checked commits on one path. |
| Image | Independent reads within bounded memory and execution capacity. |
| Browser | Explicit instance/tab routing; parallel tabs with FIFO execution per tab. |
| Computer | One desktop input owner; read-only observation remains available. |
For two AI conversations, each can select a different browser instance and open its own background tab. Both can run independent process sessions while one workflow owns desktop input. If both choose the same tab, file, repository, or cloud account, they intentionally share that resource.
Request cancellation is distinct from process execution timeout and Host shutdown. A failed or expired call retains other resources. When a side effect may already have occurred, observe the target before retrying a non-idempotent action.
Transport recovery tests cover failed requests before response headers, incomplete response bodies, protocol-specific cancellation, and transient tunnel poll and response-delivery errors. A surviving peer client and a newly connected client must remain usable after an individual failure. A cloud connection error alone identifies neither the failing hop nor whether the tool executed; diagnosis uses the individual tool name, machine time, and provider logs. Keep credentials and tool payloads private when sharing those logs.
The two-conversation acceptance prompts exercise idle browser connectivity, independent process output, explicit profile routing, and desktop ownership through configured clients. The connection guide covers Gemini OAuth setup and cross-provider acceptance against one Host.
Installation
Download a platform archive from Releases, verify its published SHA-256, and extract it into its own directory.
| Platform | Process, Filesystem, Image | Browser | Computer |
|---|---|---|---|
| Windows amd64 | Supported | Chromium extension | Native Windows engine |
| Linux / macOS | Supported | Chromium extension in a desktop browser | Reports platform unavailability |
Browser control requires Chromium 120 or newer and a running profile with the extension loaded. Windows Computer requires Windows 10 version 2004 or newer, including Windows 11, an interactive desktop, and permissions appropriate for the target applications.
The Windows archive contains:
local-runtime-mcp/
├── lrmcp.exe
├── cloudflared.exe
├── config.example.yaml
├── README.md
├── README.zh-CN.md
├── SECURITY.md
├── PRIVACY.md
├── LICENSE
├── THIRD_PARTY_NOTICES.md
├── docs/
├── licenses/
└── cloudflared-LICENSE
Copy config.example.yaml to local-runtime-mcp.yaml and fill the sections used by your selected transport and providers:
browser:
listen: 127.0.0.1:9315
token: "replace-with-a-random-token-of-at-least-32-characters"
openai:
tunnel_id: "replace-with-your-openai-tunnel-id"
api_key: "replace-with-your-openai-tunnel-api-key"
http:
listen: 127.0.0.1:9316
public_host: mcp.example.com
auth: bearer
bearer_token: "replace-with-a-random-token-of-at-least-32-characters"
cloudflare:
tunnel_token: "replace-with-your-cloudflare-managed-tunnel-token"
Protect the runtime directory as a credential-bearing application directory. Browser profile installation and identity stay with that machine's browser profile when the runtime directory moves.
Browser setup
./lrmcp.exe setup browser
The command saves bridge credentials to the adjacent YAML and extracts browser-extension beside the executable. In each intended profile, open edge://extensions or chrome://extensions, enable Developer mode, choose Load unpacked, and select that directory. Open extension options to set a distinct label and confirm the bridge address and token. Start lrmcp and use browser_status to discover connected instances.
Local stdio
{
"mcpServers": {
"local-runtime-mcp": {
"command": "C:\\Tools\\local-runtime-mcp\\lrmcp.exe",
"args": ["serve", "--transport", "stdio"]
}
}
}
OpenAI Tunnel
Fill the openai section and run:
./lrmcp.exe serve --transport http --tunnel openai
See the OpenAI Secure MCP Tunnel guide for provider setup and supported clients. The private HTTP origin is created automatically; its port and private-hop credential remain runtime-only.
Streamable HTTP
For direct HTTP access, choose http.auth: bearer, fill http.bearer_token, and run:
./lrmcp.exe serve --transport http
The default MCP endpoint is http://127.0.0.1:9316/mcp. The loopback listener accepts the configured Bearer token and can serve as a reverse-proxy origin. An OAuth-enabled origin additionally serves discovery, authorization, and token endpoints under its public HTTPS address.
Cloudflare Tunnel
Create a remotely managed Cloudflare Tunnel, route its hostname to http://127.0.0.1:9316, fill http.public_host and cloudflare.tunnel_token, configure HTTP authentication, then run:
./lrmcp.exe serve --transport http --tunnel cloudflare
The release includes the pinned cloudflared companion. Configure the remote MCP client to use https://<public_host>/mcp. With Bearer authentication, enter the MCP Bearer token in the client's token setting. With OAuth, register that client's redirect URI and use its client credentials. The Cloudflare tunnel token authenticates the tunnel process; HTTP credentials authorize MCP clients.
Both tunnels
Fill both provider sections and run one process:
./lrmcp.exe serve --transport http --tunnel openai --tunnel cloudflare
Both connections use one browser bridge, process-session registry, filesystem coordination service, and desktop controller. Provider exits are reported locally while the other live entry point continues. Keep the terminal open; Ctrl+C shuts down the complete runtime. Logs distinguish a degraded provider from an available peer.
OAuth for Gemini and other clients
Set http.public_host to the externally reachable hostname. In the MCP client's connection dialog, copy its exact redirect URI and register it locally:
./lrmcp.exe setup oauth --client-name gemini --redirect-uri "https://<client-callback-host>/<callback-path>"
./lrmcp.exe setup oauth --client-name gemini --show
The setup command saves the OAuth client and an owner approval key in the adjacent YAML, and selects http.auth: oauth. The show command displays that client's credentials locally. Enter the generated client ID and client secret in Gemini's additional settings, and use https://<public_host>/mcp as its server URL. During authorization, approve access on Local Runtime's consent page using the owner approval key. Keep that approval key with the machine's operator.
OAuth authorization grants access to the runtime's complete machine-control tool surface. Register each client with exact redirect URIs; repeat --redirect-uri when one client needs several callbacks. Access and refresh tokens are held in memory. Restarting lrmcp requires clients to authorize again. OpenAI's private-hop authentication remains independent of this public HTTP mode.
See the connection guide for the complete setup sequence, credential roles, and acceptance checks. Real client behavior is verified after connecting that client's account and callback.
Environment overrides
| Environment variable | YAML field |
|---|---|
LOCAL_RUNTIME_MCP_BROWSER_LISTEN |
browser.listen |
LOCAL_RUNTIME_MCP_BROWSER_TOKEN |
browser.token |
LOCAL_RUNTIME_MCP_OPENAI_TUNNEL_ID |
openai.tunnel_id |
LOCAL_RUNTIME_MCP_OPENAI_API_KEY |
openai.api_key |
LOCAL_RUNTIME_MCP_HTTP_LISTEN |
http.listen |
LOCAL_RUNTIME_MCP_HTTP_PUBLIC_HOST |
http.public_host |
LOCAL_RUNTIME_MCP_HTTP_AUTH |
http.auth |
LOCAL_RUNTIME_MCP_HTTP_BEARER_TOKEN |
http.bearer_token |
LOCAL_RUNTIME_MCP_OAUTH_OWNER_TOKEN |
http.oauth.owner_token |
LOCAL_RUNTIME_MCP_CLOUDFLARE_TUNNEL_TOKEN |
cloudflare.tunnel_token |
LOCAL_RUNTIME_MCP_CLOUDFLARED |
cloudflare.binary |
Run lrmcp help for corresponding command-line flags.
Build and test
Requirements: Go 1.27, Node.js 24, and Rust 1.96.0 with the Windows MSVC toolchain for the Computer engine. CI and release builds pin Rust 1.96.0, and the Windows native worker statically links the Microsoft CRT. Run the native build on Windows with the Visual Studio build environment loaded.
Push-Location browser-extension
npm ci
npm run build
npm test
Pop-Location
./scripts/build-native.ps1
cargo fmt --manifest-path native/computer-windows/Cargo.toml --check
cargo clippy --manifest-path native/computer-windows/Cargo.toml --all-targets -- -D warnings
cargo test --manifest-path native/computer-windows/Cargo.toml --locked
go test ./...
go vet ./...
go build ./cmd/lrmcp
Go tests cover shared resource lifetimes, provider supervision, HTTP authentication and OAuth flows, response correlation, cancellation, competing file commits, process I/O, and browser identity routing. Extension scheduler tests cover ordering, fairness, cancellation, and queue limits. The opt-in Windows Chromium suite loads the real extension in disposable browser profiles and includes an idle-only connection test:
$env:LOCAL_RUNTIME_MCP_BROWSER_E2E = '1'
go test ./internal/browser -run 'TestEdgeExtension(IdleLifecycle|EndToEnd)' -count=3 -v
go test ./internal/browser -run TestEdgeOAuthAuthorizationRedirect -count=3 -v
The OAuth browser regression exercises consent, cancellation, incorrect-key retry, cross-origin callback chains, client authentication, and refresh rotation with fixture credentials. CI exercises Windows, Linux, and macOS. Local protocol and browser tests validate those execution paths; live client acceptance is performed separately against the configured account and tunnel.
Security, privacy, and license
Authenticated clients operate with the authority of the account running lrmcp. Resource handles coordinate targets and workflows within that shared host. Separate tenant permissions require dedicated OS accounts or machines; browser profiles separate browser data.
See SECURITY.md for deployment guidance and private vulnerability reporting, and PRIVACY.md for local storage and provider data flows.
Local Runtime MCP is licensed under GNU AGPL v3.0 only. The separately licensed cloudflared companion and dependency attributions are documented in THIRD_PARTY_NOTICES.md.
Reviews (0)
Sign in to leave a review.
Leave a reviewNo results found