Potencia tu agente
El comando propio del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code no tiene enlace de instalación para un comando local. Copia el comando de abajo y ejecútalo en una terminal.
claude mcp add local-shell-mcp-dsh -- npx -y local-shell-mcp-dsh@5.1.4Ejecútalo en una terminal.
{ "mcpServers": { "local-shell-mcp-dsh": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
Abrirlocal-shell-mcp gives ChatGPT Developer Mode and other MCP clients controlled access to a real execution environment. It exposes a dedicated workspace with shell, persistent shell, filesystem, search, patch, Playwright, audit, durable logical sessions with optional Goal plans, public file links, and outbound remote-worker access. Git is handled through ordinary shell commands instead of a parallel wrapper API.
Runtime: Docker / VS Code extension / binary / Python / stdio
-> exposure: localhost, HTTPS proxy/tunnel, or stdio pipe
-> client: ChatGPT or another MCP client
-> controlled workspace at /workspace or configured root
-> optional remote workers connected over outbound HTTP(S)
The intended safety boundary is the container or VM, not the host.
Install the official launcher or Python package when you want a host runtime:
npx local-shell-mcp --help
pipx install local-shell-mcp
lsm --help
The npm and Python distributions both expose local-shell-mcp; installed packages also expose lsm as the short command. The npm distribution is only a verified launcher for the matching standalone release binary, not a second server implementation.
Clone the repository and prepare configuration:
git clone https://github.com/fwerkor/local-shell-mcp.git
cd local-shell-mcp
cp .env.example .env
python scripts/init_compose_env.py
Set at least these values in .env:
LOCAL_SHELL_MCP_PUBLIC_BASE_URL=https://your-public-host.example.com
LOCAL_SHELL_MCP_AUTH_MODE=oauth
LOCAL_SHELL_MCP_OAUTH_ADMIN_PIN=change-me-long-random-pin
LOCAL_SHELL_MCP_OAUTH_JWT_SECRET=change-me-64-hex-random-secret
CLOUDFLARE_TUNNEL_TOKEN=
Start the server:
mkdir -p workspaces/default
docker compose up -d
curl -i http://127.0.0.1:8765/healthz
Start the bundled Cloudflare Tunnel sidecar when you need public HTTPS access:
docker compose --profile tunnel up -d
The public MCP endpoint is:
https://your-public-host.example.com/mcp
Full setup instructions are in the documentation. Runtime choices are documented separately from client connections.
The service includes two compatible human interfaces backed by the same authenticated API and state:
local-shell-mcp tui command.Open the browser interface on the service origin:
http://127.0.0.1:8765/ui
The OAuth screen lets you choose Web UI or OpenTUI before authorization. After login, switch modes at any time from the interface selector. Native Web UI routes use URL hashes such as #/overview and #/console, so a selected mode or page can be bookmarked. The OpenTUI console retains the existing authenticated xterm.js/PTY transport, mouse interaction, automatic resizing, reconnects, fullscreen mode, and mobile shortcut row.
Standalone release executables embed the native OpenTUI runtime, while Docker images provide it inside the image. Start the service, then launch it without a human login prompt:
local-shell-mcp tui
The native TUI authenticates the loopback Human UI API with the same host-only dedicated CLI credential used by lsm call; split-runtime layouts can pass --token-file. Browser-spawned OpenTUI uses a controller-process credential created lazily in memory and never writes that privileged credential to the state directory or state backend. A dedicated local CLI credential can also invoke the registered MCP tool surface directly from shell scripts; the Human UI token is intentionally never accepted by /mcp. By default, call connects to the running loopback controller, so remote-worker calls use the live controller process instead of a separate process-local worker registry:
lsm call run_shell --json '{"command":"uname -a"}'
lsm call run_shell --json '{"command":"nvidia-smi","machine":"gpu-node"}'
printf '%s\n' '{"path":"README.md"}' | lsm call file_read
Use --session s_... to attach an ordinary tool call to a durable logical Session. In the documented Docker Compose setup, the raw LOCAL_SHELL_MCP_CLI_LOCAL_TOKEN stays only in the host-owned, permission-restricted .env; Compose passes only its SHA-256 verifier into the controller, and the CLI reads the raw value without initializing server state. Other split-runtime layouts can use --token-file <path> or the same environment variable, with the matching LOCAL_SHELL_MCP_CLI_LOCAL_TOKEN_SHA256 configured on the controller. A failed underlying command makes lsm call exit non-zero. --direct is available for standalone local calls when no controller is running; remote workers are intentionally unavailable in direct mode.
The worker-installed local-shell-mcp launcher is management-only (worker start, worker status, etc.); it exposes neither call nor tui. The worker download contains only explicitly selected execution modules, not the Controller CLI, TUI, or WebUI. Workers receive and report tasks but cannot initiate controller tool calls using worker credentials.
Files remains an LSM-native three-pane file manager inside OpenTUI for local and remote machines. It renders bounded PNG/JPEG/GIF/WebP thumbnails and provides consistent file operations through the shared service API. Manual actions entered through either human interface are excluded from the MCP audit log; Activity, Audit, and the terminal audit rail show model-originated MCP activity.
See the human interface guide.
For full shell, filesystem, remote-worker, and Playwright tools, use ChatGPT Developer Mode or another full MCP client. ChatGPT is a client connection; choose and start a runtime first.
session_manage provides one durable logical task context for agent work. A Session is deliberately independent of machine and working directory: it stores the task objective, semantic progress reports, recent execution Activity, and an optional Plan. session_id is the only durable task identity. To continue work in another ChatGPT conversation, the user explicitly passes the existing session_id, and the new agent calls session_manage(action="resume", session_id=...). Agents do not list or auto-select Sessions from other conversations. They should report the active session_id after start/resume, at meaningful progress checkpoints, and before ending a turn, while using session_manage(action="report", session_id=...) for semantic progress rather than copying every tool result into the summary. Ordinary tools receive the same task identity as logical_session_id.
When the client supports MCP Apps, workspace_open(session_id=...) opens the execution view for the explicitly selected Session as a floating MCP App and can expand to fullscreen. The v3 name open_live_workspace remains a hidden, non-enumerated compatibility alias for ChatGPT clients with a cached recipient; new integrations see and use only workspace_open. The Live Workspace is a reconnectable viewer and collaboration surface, not the owner of task state: closing it or reconnecting MCP does not discard Session progress, Activity, or its Plan. Ordinary MCP tools remain the execution API, while the app adds live operational activity, persistent terminals, file/diff inspection, jobs, remotes, audit data, and the active Session id. Clients that do not render MCP Apps continue to use the normal tool surface unchanged.
plan_manage(session_id=...) optionally enables Goal mode on that explicit Session for substantial multi-step work. An active Plan is the goal: its steps can be revised as execution changes and, while a Live Workspace is attached, the app can request continuation after 15 minutes without agent tool activity. Automatic continuation is capped at 10 continuation attempts (accepted or rejected) and resumes the same Session before continuing. Blocked, completed, and cancelled Plan statuses are never nudged; an active Plan whose steps are all completed or skipped remains eligible for cleanup continuation so a resumed agent can call plan_manage(action="finish"). A Session does not require a Plan.
https://your-public-host.example.com/mcp.Read the dedicated ChatGPT connector guide.
The DSH bridge is published separately as local-shell-mcp-dsh. With a normal LSM HTTP/MCP service running on the same host, install the plugin into a DSH profile:
dsh plugin --profile web add local-shell-mcp-dsh
The bundle uses an LSM-aware Streamable HTTP bridge and keeps the complete LSM tool surface, including remote_manage, remote_transfer, browser tools, and Dynamic MCP tools. Each DSH Session receives a stable v4 logical-session identity, so its Logical Session, active run, Activity, and native Live Workspace view stay isolated from other DSH conversations and survive DSH-side MCP transport recreation. DSH sees model tools under the normal mcp__lsm__* namespace. The DSH npm package follows the same release version as LSM. Repository installs remain useful for development from a checkout.
See the DeepSeek Harness integration guide.
Release assets include local-shell-mcp-<version>.vsix. The extension is a runtime launcher for the current VS Code workspace. It starts the same server, checks /healthz, copies the MCP URL, and copies a ready-to-paste ChatGPT setup prompt.
Basic flow:
Install executable -> install VSIX -> open a workspace -> Start Server -> copy MCP URL
For public ChatGPT access, expose the local server through an HTTPS tunnel and set local-shell-mcp.publicBaseUrl in VS Code settings. Keep local-shell-mcp.allowFullContainer disabled for direct host usage; enable it only inside disposable containers or VMs.
Remote worker mode is enabled by default. Create a one-time invite on the control server, paste the generated command on a remote machine, then use the normal tools with their optional machine argument. Only worker administration retains remote_* names.
This is intended for:
See the remote workers guide.
Skills are discovered from three ordered sources: project-level /workspace/.agents/skills, the LSM-managed /workspace/.local-shell-mcp/agent_config/skills, and global ~/.config/agents/skills. Higher-priority sources override lower-priority Skills with the same name, and symlinked Skill directories and files are supported.
This makes the universal Skills CLI layout work directly, for example npx skills add owner/repo --agent universal -y. Use skill_list to discover installed Skills, skill_load to load one instruction set, and skill_read to read a related file by the returned Skill-relative path. Changes are detected on the next call; no per-Skill MCP tools are registered and no client reconnect is required.
See the Agent Skills guide.
The public MCP surface includes:
workspace_open opens the reconnectable MCP App for the current logical Session.run_shell, run_python, persistent shell_*, and tracked job_* tools. Use run_shell for Git CLI operations.file_list, file_tree, file_glob, file_grep, unified file_read, native-vision image_view, file_write, unified file_edit, file_delete, and file_patch.remote_transfer for files or directories across controller and worker endpoints.mcp_manage, mcp_tool_search, mcp_tool_inspect, and mcp_tool_call. External tools are discovered progressively and never expand LSM's own tools/list surface.browser_session, browser_snapshot, and browser_act; browser_run_script is the low-level Playwright escape hatch.gui_list, gui_state, and gui_action for native Linux/Windows/macOS application control with accessibility-first targeting and screenshot fallback; Native WebUI also provides a low-bandwidth WebSocket Desktop stream over the same backends without per-frame tool RPCs.link_create, link_list, link_revoke.remote_manage with invite, list, rename, and revoke actions; normal execution tools accept optional machine.skill_list, skill_load, skill_read.session_manage for durable task context, progress handoff, agent-run takeover, and cross-run inheritance.plan_manage for optional Session-owned Goal mode and automatic continuation.environment_get (including version information), secret_scan, and audit_tail.Both run_shell and run_python accept persist_on_timeout (default false). Set it to
true to start the command as a tracked job and wait up to timeout_s; if it is still
running, the tool returns timed_out: true, job_id, and job_status without stopping
or rerunning the command. Continue with job_tail, job_list, and job_stop, supplying
the same machine for remote jobs. Opted-in calls use the job runner's combined
stdout/stderr log, including when the command finishes within the wait period.
lsm call run_shell --json '{"command":"make test","timeout_s":10,"persist_on_timeout":true}'
lsm call run_python --json '{"code":"import time; time.sleep(60)","timeout_s":10,"persist_on_timeout":true}'
The detailed tool reference, including purpose, inputs, returns, combinations, and notes for every tool, is available in the docs.
The following independently maintained projects explore adjacent session and orchestration models around LSM:
This project intentionally exposes powerful tools. Treat the connected model as having control of the container or VM.
Default protections include:
/workspace unless full-container mode is explicitly enabled.Get-ChildItem -Recurse, find, rg, and grep -R): it blocks recognized wide unbounded scans, bounds narrower expensive discovery, and redirects agents toward scoped file tools. It is not a shell security boundary.0600 state file and redacted from tool results and Audit arguments./workspace/.local-shell-mcp/audit.jsonl.Hard rules:
/var/run/docker.sock.LOCAL_SHELL_MCP_AUTH_MODE=none on a public network.local-shell-mcp-credentials Docker volume as sensitive.For vulnerability reporting, read SECURITY.md.
Copy .env.example for the standard setup. The configuration reference documents every environment variable and the optional YAML format for advanced deployments.
Important options:
Install development dependencies and run checks:
python -m venv .venv
. .venv/bin/activate
pip install -e '.[dev,docs]'
ruff check .
pytest -q
mkdocs build --strict
Build the VS Code extension:
npm --prefix vscode-extension install
npm --prefix vscode-extension run compile
Contribution workflow is documented in CONTRIBUTING.md.
DeepSeek Harness bridge for the full local-shell-mcp tool surface and per-session Live Workspace.
{ "mcpServers": { "local-shell-mcp-dsh": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Local Shell MCP Dsh se ejecuta localmente por stdio.
Última comprobación: 2026-11-12. DeepSeek Harness bridge for the full local-shell-mcp tool surface and per-session Live Workspace.