dsh web: http://127.0.0.1:3080 explained
dsh prints http://127.0.0.1:3080 because the Web UI binds to localhost only. Reach it safely with an SSH tunnel, and see why publishing 3080 is unsafe.
What dsh web: http://127.0.0.1:3080 means
When you start the DeepSeek Harness web profile on a VPS, it prints a line like this and then waits:
dsh web: http://127.0.0.1:3080/?token=...127.0.0.1 is the loopback address. It is the address a machine uses to talk to itself. A socket bound to 127.0.0.1 accepts connections from processes on that same machine, and from nowhere else. So that line tells you two things at once: where the Web UI is listening, and who is allowed to reach it. Only the machine dsh is running on. The ?token= part on the end is a fresh random credential that the process mints every time it starts. More on that below.
That is why the URL does nothing when you paste it into the browser on your laptop. Your laptop's 127.0.0.1 is your laptop. The harness is listening on the VPS's 127.0.0.1, which is a different machine with a different loopback stack. Nothing is broken. You need to carry the connection across.
The official README states the default plainly: "The command starts the Web UI at http://127.0.0.1:3080 by default and opens it in the default browser for a local launch." Over SSH there is no browser to open, so the URL is left for you to use by hand. The bind address comes from the webserver host plugin, @deepseek-ai/dsh-host-webserver. In the 0.2.0-rc.2 release this guide pins, its host key is documented as "Listen host; the two supported values are loopback and all-interfaces". Loopback is what you get unless you go and change it. If ports are new to you, how ports work on Linux covers the address-plus-port model this all rests on.
Why the Web UI binds to localhost only
dsh is an agent harness, which is the program wrapped around the model: it owns the loop, the tool calls and the permissions those calls run under. The browser tab is a control surface for a process that runs shell commands, reads and writes files in the workspace directory you chose, and spends your model API key. Anyone who can load that page can do all of that as the user running dsh. The network is not the only way into that reach either: a plugin you install runs inside the same process with the same permissions, which is why vetting a dsh plugin before you install it deserves the same care as deciding what the server listens on.
So port 3080 is not a read-only dashboard. Loading that page gives command execution on the server.
Open the printed URL and you land straight in the session list. There is no login screen and there are no user accounts. What gates the page is the token on the end of the URL: the root page swaps it for a signed session cookie and redirects to a clean address. After that, every RPC call and WebSocket stream the UI makes without a valid cookie gets 401 Unauthorized. Not everything on the port is gated, though. The Connection plugin's documentation says static assets remain public, and the webserver itself has no server-wide authentication or origin policy, so each plugin that owns a route enforces its own rules. On those protected routes, the Connection plugin also answers 403 when the Host header is neither loopback nor a host you explicitly trusted. On loopback that is a sensible second layer behind the real access control, which is the operating system letting only local processes through. It is not a reason to publish the port. The token sits in your terminal scrollback and in any log that captured the startup output. The project's own reverse proxy guide says that neither its Host check nor the advertised URL protects the listening port itself. The webserver documentation warns that binding a non-loopback address "still exposes unprotected routes and static assets to that network". And in 0.2.0-rc.2 the webserver plugin carries no TLS of its own. Automated scanners sweep uncommon ports continuously, so treat a published 3080 as found.
Do not open port 3080 in your firewall, and do not set the webserverhostto0.0.0.0, or to your public IP, on a public VPS. That combination leaves command execution on your server one leaked URL away from whoever connects.
Current releases already push you this way: the web application's own --host flag refuses to bind all interfaces. In 0.2.0-rc.2, though, the webserver plugin's host config key still accepts 0.0.0.0, so a config edit can still expose it. The webserver documentation on the project's default branch, and in the 0.2.1-rc.5 release that npm's latest tag now points to, goes further: it rejects an unspecified address at load and adds an optional tls setting. It still accepts any one concrete address of a local interface, so pointing host at your VPS's public IP exposes the UI all the same.
The same reasoning applies to every agent runtime you put on a server, which is why running a coding agent safely on a VPS starts from the same rule: the agent's control port stays private, and something you trust carries you to it.
How do I open the dsh Web UI from my laptop?
There are three honest ways, and every one of them leaves the harness bound to loopback.
- An SSH tunnel. Nothing new listens on the public interface, and you already have the credentials. This is the one to use.
- A private overlay network, so the UI is reachable from your own devices and invisible to everyone else.
- A reverse proxy that terminates TLS (transport layer security) and demands a password before it forwards anything.
The difference between them is what carries your browser to loopback. None of them should involve moving the harness off loopback.
Reach it with an SSH tunnel
Run this on your laptop, not on the VPS:
ssh -N -L 3080:127.0.0.1:3080 you@your-vpsLeave it running, then open the full URL dsh printed, http://127.0.0.1:3080/?token=... with the token included, in your local browser. The Web UI loads, trades the token for a session cookie, and drops the token from the address bar. Your browser sends 127.0.0.1:3080 as the Host, which is loopback, so the tunnel passes the Host check with no extra configuration.
The -L argument holds three fields separated by colons. The first is the port to open on your laptop. The second and third are the address and port to forward each connection to. The detail that matters: 127.0.0.1 in the middle field is resolved by the SSH server on the VPS, after your traffic has already arrived there. It means the VPS's loopback, not yours. That is precisely the address dsh printed, which is why the tunnel works when a direct browser connection does not.
-N tells SSH not to run a remote command, so you get a forwarder and no shell. For a background tunnel that fails loudly instead of quietly:
ssh -N -f -o ExitOnForwardFailure=yes -o ServerAliveInterval=30 -L 3080:127.0.0.1:3080 you@your-vps-f drops it into the background after authentication. ExitOnForwardFailure=yes matters more than it looks: without it, SSH connects successfully even when the forward could not be set up, so you get a working session and a dead tunnel with no warning. ServerAliveInterval=30 sends a keepalive every 30 seconds so an idle tunnel survives NAT (network address translation) timeouts on café and hotel routers.
What you should see
On the VPS, confirm what is actually listening:
ss -ltnp | grep 3080A healthy result names the loopback address:
LISTEN 0 511 127.0.0.1:3080 0.0.0.0:* users:(("node",pid=1042,fd=21))If the local address column reads 0.0.0.0:3080 instead, the Web UI is on every interface, including the public one. Your VPS's public IP in that column means the same exposure. Stop it and fix the bind before you do anything else. If ss prints the socket but leaves the users: field empty, run it with sudo, because the process name for a socket owned by another user is hidden otherwise.
When the tunnel refuses to start
SSH prints this and exits:
bind [127.0.0.1]:3080: Address already in use
channel_setup_fwd_listener_tcpip: cannot listen to port: 3080This is about your laptop, not the server. Something local already holds port 3080, often an earlier tunnel you forgot. Pick a free local port instead:
ssh -N -L 3081:127.0.0.1:3080 you@your-vpsOnly the first field changed, so you now browse to http://127.0.0.1:3081/?token=..., with the same token, while the harness keeps listening on 3080. The two numbers never have to match. The session cookie is bound to the host and port in the address bar, so a new local port needs the token URL once more.
If the tunnel comes up but the browser reports a refused connection or an empty reply, the traffic crossed to the VPS and found nothing on the far end. Either dsh exited, or it bound a different port. Check with ss -ltnp | grep 3080 on the server. If the page instead answers 401 Unauthorized, the tunnel is fine and your browser simply holds no valid cookie for that address: open the printed URL again, token included. After a restart, take the URL from the new output, because each process mints a fresh token.
One more thing bites people here. A foreground npx @deepseek-ai/dsh web dies when its shell closes, so the harness stops the moment you log out. Start it inside tmux or under a systemd user service, which is the same problem solved in keeping a coding agent running on a VPS. Under systemd the dsh web: line, token and all, lands in the service log, so read it from there. While you are working on the SSH side, hardening SSH on your VPS is worth doing first, because the tunnel makes your SSH login the only door to the agent.
Reach it over a private overlay network
An overlay network gives your VPS and your laptop addresses on a private network that only your devices join. Tailscale is the common choice, and its serve command fits this case exactly: tailscaled runs on the VPS and connects to localhost:3080 itself, so the harness stays on loopback.
tailscale serve --bg localhost:3080
tailscale serve statusThe UI is then reachable at your machine's name inside your tailnet, over HTTPS, with no port open on the public interface. This needs HTTPS certificates enabled for your tailnet, otherwise serve has no certificate to present. Because your browser now sends that tailnet name as the Host, start the harness with the name trusted, or its API calls get 403. An entry without a port matches any port:
npx @deepseek-ai/dsh@0.2.0-rc.2 web --trusted-host your-vps.your-tailnet.ts.netThen open https://your-vps.your-tailnet.ts.net/?token=..., carrying the token over from the printed line. To take it down again, repeat the command with off:
tailscale serve --https=443 offUse serve, never funnel. Funnel publishes the same target to the public internet, which puts an agent runtime on an open port with nothing but a URL token in front of it. The two commands look almost identical and do opposite things, so read the difference between Tailscale Serve and Funnel before you type either. Tailscale as a private network covers the setup itself.
Reach it through a reverse proxy that checks a password
This is the option that genuinely publishes a port to the internet, so the authentication is the only thing standing between a stranger and command execution on your server. Choose it when several people need the UI and a tunnel each is impractical.
The harness stays on 127.0.0.1:3080. nginx runs on the same box, so it can reach loopback, and it listens on 443 with a certificate and a password file.
server {
listen 443 ssl;
server_name dsh.example.com;
ssl_certificate /etc/letsencrypt/live/dsh.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/dsh.example.com/privkey.pem;
auth_basic "dsh";
auth_basic_user_file /etc/nginx/dsh.htpasswd;
location / {
proxy_pass http://127.0.0.1:3080;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_read_timeout 3600s;
proxy_buffering off;
}
}Create the password file and reload:
sudo apt install -y apache2-utils
sudo htpasswd -c /etc/nginx/dsh.htpasswd you
sudo nginx -t && sudo systemctl reload nginxnginx -t should print syntax is ok followed by test is successful. A reload with a broken file fails and leaves the running configuration in place, so read the error rather than restarting blindly.
Three of those proxy lines are not decoration. The Upgrade and Connection headers let the WebSocket handshake through, and without them the page loads but never updates. proxy_read_timeout 3600s raises nginx's inactivity timeout from 60 seconds to an hour; it does not limit the total length of an agent run. The pinned 0.2.0-rc.2 already sends WebSocket pings every two seconds by default, keeping that connection active during a long agent step. proxy_buffering off disables buffering for proxied HTTP responses; it does not control WebSocket frames. An nginx reverse proxy config, line by line explains the rest, and choosing between nginx, Caddy and Traefik covers doing the same thing with automatic certificates.
The harness needs to know about the proxy too. proxy_set_header Host $host passes the browser-facing name through unchanged, which is what the project's proxy guide asks for, so start dsh with that name trusted or it answers 403:
npx @deepseek-ai/dsh@0.2.0-rc.2 web --trusted-host dsh.example.comEach person then opens https://dsh.example.com/?token=... once, with the token from the dsh web: line, and the browser keeps the session cookie after that. The backend sets that cookie without the Secure flag, and the proxy guide asks the proxy to add it on HTTPS. On nginx 1.19.3 or newer, proxy_cookie_flags ~ secure; in the location block does that.
Keep 3080 closed at the firewall no matter which proxy you pick, so the only path in is through the authenticated one. ufw firewall basics covers the rules. Basic authentication over TLS is a floor, not a finished security model: whoever holds that password and the token URL holds a shell on your server. Prefer the tunnel when you can.
How do I change the port dsh web listens on?
--port belongs to the web application, not to the launcher. The CLI documentation gives the example directly:
dsh --profile web --port 8080dsh web is an alias of --profile web, so dsh web --port 8080 is the same command. The launcher parses only its own flags and hands everything after them to the booted profile. Launcher flags therefore come first, and the first token the launcher does not recognise starts the application's arguments. Put --port after the profile, never before it.
Read the URL the command prints rather than assuming it, because that line reports the address the server actually bound, along with the token you will need. Then update the last field of your tunnel to match:
ssh -N -L 3080:127.0.0.1:8080 you@your-vpsFor a permanent change, the port lives in the profile configuration instead of on the command line. The web and headless profiles auto-initialise on first use from shipped templates, under ~/.dsh. That same directory is where your API key and model endpoint settings live, so configuring dsh keys, models and endpoints is the companion read once you are editing these files anyway. To see what is actually in effect after all the layers compose:
dsh --dump-configThe listen address comes from two keys in the webserver plugin, host and port. In 0.2.0-rc.2 its other keys only tune response compression, and 0.2.1-rc.2 and the default branch add an optional tls key. Setting port to 0 asks the operating system for a free port, documented as "zero requests an OS-assigned port". That guarantees you never hit a conflict, and it is a poor fit for a tunnel, because the number changes on every restart.
Why does dsh fail with address already in use?
Because another process already holds that address and port, so the kernel refuses the second bind. Node reports it like this:
Error: listen EADDRINUSE: address already in use 127.0.0.1:3080Find the holder before you change anything:
sudo ss -ltnp | grep 3080The users:(("node",pid=1042,fd=21)) field names the process and its PID. The usual answer is an earlier dsh that you thought had stopped, often still alive in a detached tmux window. Stop that one with kill 1042, or start the new instance on a different port. Note that 127.0.0.1:3080 and 0.0.0.0:3080 also collide with each other, because binding all interfaces already covers loopback.
Pin the version, because this is a developer preview
The README is blunt about it: DeepSeek Harness is in developer preview and iterating rapidly, and there will be compatibility-breaking changes. If that pace is the reason you are hesitating, how dsh compares with Claude Code and Omnigent weighs it against two harnesses at different points on the same curve.
An unpinned npx @deepseek-ai/dsh web names no version, so you do not control which build it starts. npm's documentation says a package name without a specifier "will be matched with whatever version exists in the local project", and a package missing from the project is installed into a folder in the npm cache. Which build starts depends on what that machine happens to have, so a restart can bring up a different CLI from the one you tested, with different flags. Pin the version so a restart is not an upgrade:
npx @deepseek-ai/dsh@0.2.0-rc.2 webAs of November 2026 (checked on 2026-11-01), the npm latest tag points to 0.2.1-rc.5, released on GitHub on 2026-10-30. GitHub records 0.2.1-rc.4 as released on 2026-10-28 at 02:49 UTC, approximately four days and eleven hours after 0.2.1-rc.3 on 2026-10-23 at 15:26 UTC. So on a machine with no local copy, a bare npx @deepseek-ai/dsh now pulls a 0.2.1 release candidate, not the build this guide pins. The pinned 0.2.0-rc.2 was released on GitHub on 2026-09-29. The 0.1.0-rc.7 build this guide pinned in August is now many preview releases behind, across the rest of the 0.1 line and into 0.2. Check what a bare npx would pull before you accept it:
npm view @deepseek-ai/dsh versionnpm view @deepseek-ai/dsh dist-tags lists every tag at once, which is how you tell a release candidate from an alpha before you pin it.
If the pin refuses to install, or npx keeps starting the old build after you pinned a new one, the install and version errors this throws covers clearing the npx cache and checking which npm your Node bundles.
Flags move between the launcher and the web application across preview releases. If --port stops behaving the way this guide describes, ask the application for its own flag list rather than guessing:
dsh --profile web --helpFor the install itself, the workspace setup and the model key, see installing DeepSeek Harness on a VPS. For a shorter walkthrough of the access step alone, reaching the dsh Web UI on a VPS covers the tunnel without the reasoning.
FAQ
Why can I not open http://127.0.0.1:3080 in my laptop browser?
Because 127.0.0.1 means the machine you are typing on. The DeepSeek Harness Web UI is bound to the VPS's loopback address, so only processes on the VPS can connect to it. Your laptop has its own separate loopback, and nothing is listening on port 3080 there. Forward the port over SSH with ssh -N -L 3080:127.0.0.1:3080 you@your-vps, then load the full printed URL, http://127.0.0.1:3080/?token=..., locally. The middle field of the -L argument is resolved on the server side, which is what makes it point at the harness. Leave the token off and you get 401 Unauthorized until your browser holds a session cookie.
Is it safe to bind the dsh Web UI to 0.0.0.0 on a public VPS?
No. The Web UI is the control surface for an agent that runs shell commands and edits files as the user running dsh. It has no user accounts and no login screen: the only credential is the token in the printed URL, static assets are served without it, and the project's own docs say the listening port itself is unprotected. Binding to all interfaces on a public IP puts command execution on your server one leaked URL away from anyone who reaches port 3080. Binding to the public IP directly carries the same risk. Keep the bind on 127.0.0.1, keep 3080 closed at the firewall, and use an SSH tunnel, a private overlay network, or a reverse proxy that requires a password.
How do I keep the dsh Web UI running after I close my SSH session?
A foreground npx @deepseek-ai/dsh web is a child of your login shell, so it is killed when that shell exits. Start it inside a tmux session and detach with Ctrl-b d, or run it as a systemd user service with lingering enabled. The tunnel and the harness are independent: you can drop and rebuild the SSH tunnel as often as you like without touching the running harness, as long as the harness itself has a parent that outlives your login.
Why does the dsh Web UI freeze part way through a long agent run behind nginx?
Check the WebSocket connection and nginx's error log. nginx's default proxy_read_timeout is 60 seconds between reads, but the pinned 0.2.0-rc.2 sends WebSocket pings every two seconds by default, so a long agent step alone does not trigger that timeout. proxy_read_timeout 3600s; raises the inactivity allowance to an hour. proxy_buffering off; disables buffering for HTTP responses, not WebSocket frames. Pass the Upgrade and Connection headers with proxy_http_version 1.1; so the WebSocket handshake succeeds. Without those headers the page loads but never receives an update.