Mobile Access — when something is wrong (part 3)
Part 3 of the Mobile Access page: the troubleshooting walkthrough for a phone connection that will not behave, followed by the internals — how the mobile transport, session handling and resume actually fit together for anyone working on the code.
On this page
What it is
This is part 3 of the Mobile Access page. It is the half you reach for when the phone will not connect or will not stay connected.
Where to find it
The troubleshooting section is for reading while you are in front of a phone that is misbehaving; the internals are agent- and developer-facing.
How it behaves
Troubleshooting
When something is wrong, the Settings → Remote Access pane in Omniscio shows one of four banners with verbatim copy. Match what the user is seeing on screen against the headers below to pick the right fix. Omniscio polls Tailscale every 5 seconds while the pane is open, so any state change (login, online/offline, ACL grant) takes up to 5s to reflect — close and re-open the pane to force an immediate re-check.
Banner: "Tailscale is required for mobile access"
Body text: "Tailscale creates a secure private network so you can access Omniscio..."
Cause: Omniscio can't find the tailscale binary. It resolves it against the live system / login-shell PATH first (Windows registry; sh -lc 'echo $PATH' on macOS/Linux), then falls back to standard install paths: C:\Program Files\Tailscale\tailscale.exe and C:\Program Files (x86)\Tailscale\tailscale.exe on Windows; /usr/bin/tailscale, /usr/local/bin/tailscale, /opt/homebrew/bin/tailscale (Apple-Silicon Homebrew), /usr/sbin/tailscale on macOS/Linux. A PATH hit is version-checked before it is trusted, so a dead wrapper (a leftover /usr/local/bin/tailscale shim pointing at an uninstalled /Applications/Tailscale.app) is skipped and detection continues to the working binary.
Fix: Install Tailscale from https://tailscale.com/download. Omniscio re-reads the live PATH on every detection, on every platform — a GUI app launched from Finder/Dock or the tray does not inherit the shell PATH, so a Homebrew / nvm / custom-prefix install you can run in a terminal is found this way — so an install done after Omniscio launched is picked up automatically. If the banner doesn't clear within ~5 seconds, close and re-open the Settings pane, or restart Omniscio. If it persists with Tailscale clearly installed, the binary is in a non-standard path; reinstall to the default location.
Banner: "Tailscale needs sign-in"
Body text: "Open Tailscale and sign in to enable mobile access."
Cause: The Tailscale daemon reports BackendState: NeedsLogin or NoState. Tailscale is installed but no user is signed in.
Fix: Click the Tailscale icon in your system tray → Log in. A browser window opens; sign in with the Google or Microsoft account on your tailnet. The banner clears within ~5s of successful login.
Inbox card: "Mobile Access is paused until Tailscale is signed in"
Cause: Mobile Access has not been able to connect for ten minutes or more, and Tailscale reports BackendState: NeedsLogin — an expired node key, a sign-out, a reinstall or an OS account change. No retry can clear that, so this card does not promise one; the ordinary outage card ("Mobile Access can't connect through Tailscale") says Omniscio keeps retrying and clears itself. A backend in NoState is not a sign-out and keeps the ordinary card, because on Windows Omniscio relaunches the Tailscale app by itself (its status line reads "Tailscale is not running. Open the Tailscale app to start it").
Fix: sign in to Tailscale on the computer itself — it cannot be done from the phone. The card clears by itself once the computer is signed in and the tunnel is serving again. The newest observation decides the wording, so a later ordinary outage goes back to the retrying card.
Banner: "Tailscale is offline"
Body text: "Check your internet connection. Mobile access will be available when Tailscale..."
Cause: Logged in, but the daemon reports Self.Online: false. Usually transient network loss, sleep/resume, or the Tailscale daemon paused.
Fix: Confirm internet works on the PC. Right-click the Tailscale tray icon — if it shows Disconnected or Paused, click Connect/Resume. If the daemon is wedged, Exit Tailscale from the tray and re-launch from the Start menu / Applications folder.
My phone can't open the private address
Mobile Access is private by default: the https://<machine>.<tailnet>.ts.net/ address only opens on devices signed in to the same Tailscale account as the desktop. Anything else (a phone without the Tailscale app, one signed in to another account, or one with Tailscale switched off) gets no connection at all, which is the point.
Fix: install the Tailscale app on the phone, sign in to the same account, turn it on, then scan the pairing QR again. If a device genuinely cannot run Tailscale, either pair over the same Wi-Fi, or turn on Allow access from the public internet in Settings → Remote Access → Advanced (desktop only), which switches to Tailscale Funnel.
Notice: "HTTPS certificates are turned off"
Body text: "Tailscale access is off because HTTPS certificates are turned off for your Tailscale network. Turn them on, and Mobile Access connects automatically."
Cause: private (and public) Tailscale access needs a certificate for <machine>.<tailnet>.ts.net, and the tailnet's HTTPS certificates setting is off. Tailscale answers tailscale serve --bg with an enable-HTTPS prompt instead of registering the address. Omniscio treats this as a permanent setup problem: it shows the notice (also after a failed start at boot), offers Open Tailscale admin to fix this (Tailscale's own one-click link when it printed one, otherwise https://login.tailscale.com/admin/dns), and the background reconciler backs off for 10 minutes instead of retrying every minute.
Fix: open the link, turn on HTTPS certificates in the Tailscale admin console's DNS page, then wait (or toggle Mobile Access off and on). No change on the phone is needed.
Banner: "Tailscale Funnel needs approval"
Body text: "Toggle Mobile Access on and your browser will open to approve Funnel access. Just click approve and you're set."
This appears only when public access is turned on (Settings → Remote Access → Advanced → Allow access from the public internet). Private access, the default, needs no Funnel permission, so a tailnet without it still reaches the ready state and starts privately.
This is the most common point of confusion in public mode. Funnel requires two independent permissions, both of which can be missing:
- Device capability — the machine must have the
funnelcapability advertised in the tailnet (visible intailscale status --jsonunderSelf.CapMap, keyhttps://tailscale.com/cap/funnel). - Tailnet ACL policy — the tailnet's admin policy must explicitly grant Funnel to this device. On free Tailscale plans this is a one-time toggle.
When the user clicks the tunnel toggle and gets this state, Omniscio also surfaces a clickable Open Tailscale admin to fix this link. Omniscio parses that URL out of the Tailscale CLI's stderr from tailscale funnel --bg <port> and falls back to https://login.tailscale.com/admin/acls if no URL is embedded in the error.
Fix: Click the admin link in Omniscio's banner, approve Funnel for this device in the Tailscale admin console, then return to Omniscio and toggle the tunnel again. If the admin link doesn't appear, visit https://login.tailscale.com/admin/acls directly and confirm the policy grants Funnel to this device's tag or user.
Tunnel toggle won't stay on, no clear banner
The toggle flips on then back off without an obvious banner. Likely causes:
- Port conflict — default
9876is already bound by another process. Try a different port (range 1024–65535; uncommon picks like19876or28765avoid most conflicts). Omniscio raises an inbox card for this — "Remote Access could not start" naming the port and the reason — including the case where its off-loop worker loses the port and the in-main fallback then can't claim it either, so a phone that can't connect always arrives with the cause instead of only a reassuring "no action needed" line. - First-time certificate provisioning — Tailscale provisions a LetsEncrypt cert the first time the address is used over HTTPS (private or public), which can take 30–60 seconds. Retry once after a minute.
- Tailscale daemon mid-restart — the daemon is briefly unreachable; wait 30 seconds and retry.
"Mobile Access is on but its key is missing"
This inbox card means Mobile Access is switched on but the saved pairing key is empty, so the phone server and the tunnel were not started. Click Open Mobile Access settings and pair the phone again; the card clears itself the moment Mobile Access starts, and also when Mobile Access is switched off. Before 2026-11-01 this case was silent: on 10-31 a second app process that could not open the keyring saved blank secrets, the desktop adopted them, and every later boot skipped Mobile Access with no log and no card. The config store no longer adopts a blank over a secret it holds (see the config-store contract's adopt-keeps-a-known-secret-over-a-failed-decrypt).
What the boot start does, in order
start-web-access.ts runs once per boot, fire-and-forget, at the position the app.whenReady() callback always had. Switched off: it clears the key-missing card. On with no key: it raises that card and logs a warning. On with a key: it starts the listener, bound to loopback unless Settings → Advanced chose 0.0.0.0, and resumes the key's idle window from webAccessTokenLastUsedAt and its absolute lifetime from webAccessTokenCreatedAt, so a restart never resets either. A listen error raises the "Web access bind failed" card and skips the tunnel, which needs the listener; a clean start clears both cards (every start path goes through startWebAccessTransport). The sequence is awaited for at most 90 s so it can never land on the boot path, but the tunnel retries keep running past that. The retry waits use full jitter so retries from many machines never line up. After the tunnel is up, the off-loop server's host allow-list is refreshed so the tunnel hostname passes the DNS-rebinding check.
Restarting Omniscio itself
When Omniscio restarts, the phone says so instead of warning that it cannot reach your computer — see When your phone can't reach your computer. On a computer running from source code, a private Tailscale tunnel now stays up through the restart, so the phone can still reach the computer and show the rebuild step; a public (Funnel) tunnel is still switched off and comes back when the app does.
Just restarted the PC and the tunnel isn't up yet
On app launch, if tunnelEnabled is on, Omniscio starts the tunnel in the background. Tailscale's own daemon (and the system PATH) may still be initializing — production launches frequently beat Tailscale to ready. Omniscio retries up to 8 times with exponential backoff — 7 delays of 3s, 6s, 12s, 24s, 48s, 60s, 60s, about 3.5 minutes. The decision lives in isRetryableTunnelStartError() (tunnel-service.ts), called from the boot loop in index.ts. It is a permanent-error deny-list, not a retryable allow-list: only Funnel not enabled in the tailnet admin console (public mode; an ACL decision a retry can't change) and HTTPS certificates turned off (private or public; see the notice above) stop immediately. Every "not ready yet" shape retries — tailscale status failing before the daemon answers, the binary not yet on PATH (not installed), not-logged-in, offline, and a not-yet-populated DNS name.
A busy machine can't fake "not installed" anymore. A restart leaves the PC slammed (dozens of sessions resuming), and the 5-second tailscale version probe can time out on a healthy install. Discovery now trusts a probe killed on timeout when the binary exists on disk (used immediately, re-verified next check), while a fast failure — missing file, dead shim — is still rejected. Before 2026-07-02 one slow probe made Omniscio conclude "Tailscale is not installed" for 8 minutes, blinding the boot retry and the reconciler (postmortem). Concurrent start attempts also share one run instead of bouncing off each other with "already in progress" errors.
Beyond that window, a background Tunnel Reconciler keeps it covered. The 8-attempt loop is only the fast path. If Tailscale isn't ready in ~3.5 minutes — mid auto-update after a reboot, say — the loop gives up and a separate Tunnel Reconciler (tunnel-reconciler.ts) takes over: every 60 s, while tunnelEnabled is on and the funnel is down, it re-attempts startTunnel() until Tailscale is ready and the funnel comes up — no toggle, no restart. It reuses the same classifier (a genuine Funnel not enabled ACL error backs off 10 minutes), is quiet (no inbox alert), and is default-on with an AMC_DISABLE_TUNNEL_RECONCILER=1 kill switch. This closes the gap where rebooting during a Tailscale update left mobile dead with "No serve config" though Tailscale was healthy. Invariants: tunnel-reconciler-contract.md.
It no longer trusts "the tunnel started" to mean "your phone can reach it" (2026-07-05; split by mode 2026-09-26). In private mode (the default) the reconciler checks Tailscale's own record (tunnel-registration-probe.ts): tailscale serve status --json must list our address, pointing at our port, and not public. Missing, pointing elsewhere, or public counts as not serving and is repaired after the usual 3 checks; a record it cannot read counts as "couldn't check" and never triggers a teardown. tailscale funnel --bg can return success while Tailscale's public ingress never routes to the machine — observed when the command runs on a still CPU-starved box after a restart. The old reconciler trusted that "funnel is up" flag and went silent; the phone stayed dead for 12 minutes despite a logged "Tunnel started". Now, when the funnel is registered, it verifies the real public path your phone uses (funnel-health-probe.ts), bypassing a trap: on the host, MagicDNS resolves the ts.net name to the machine's own tailnet IP, so a naive probe would pass even when the outside world can't connect — so the probe resolves the public ingress via public DNS and dials it with the funnel's SNI. If a registered funnel isn't serving for 3 consecutive checks (~3 min — a lone blip never triggers it), it re-establishes cleanly — funnel off then funnel --bg, the automated off/on toggle — with a 5-minute anti-flap cooldown, and keeps going until your phone can reach it. Invariants I10/I11.
It will not tear a working tunnel down just because it couldn't check (2026-09-09). The check used to answer a plain yes/no, so "I couldn't tell" and "it's broken" were the same answer — and both triggered a rebuild that disconnects every phone; a demonstrably fine tunnel was rebuilt 30-plus times a day. Rebuilding cannot fix an address that won't resolve. It now answers yes / no / couldn't-tell, always with a written reason; only a proven "no" rebuilds anything. The lookup retries, tries every address it gets back rather than only the first, is capped by a hard overall deadline, and remembers the last address that worked. If it can't verify for ~30 minutes it makes one rebuild attempt anyway, so a truly dead tunnel still can't sit unhealed. See the funnel false-teardown postmortem.
On Windows it also recovers a dead Tailscale GUI (2026-07-27). Tailscale's background service runs headless, but on Windows its backend needs the per-user Tailscale GUI (tailscale-ipn.exe) connected to reach Running/online — and a Windows Update to the WindowsAppRuntime can kill that GUI so it never relaunches, leaving the backend wedged in BackendState: NoState, offline, with the funnel gone. A plain Tailscale-service restart or tailscale up does not clear this — only relaunching the GUI does (confirmed live: service restart + tailscale up both failed; relaunching tailscale-ipn.exe took the backend NoState → Running in ~15 s). So when the reconciler finds the funnel down and the backend in NoState on Windows, it relaunches tailscale-ipn.exe itself (no admin needed) before re-attempting the start; the backend comes online within seconds and the next tick brings the funnel back. Windows-only, at most once every 2 min, log-only. Invariant I12.
Fix: Just wait — the tunnel self-heals: first the boot retry (~3.5 min), then the reconciler (every 60 s), so a slow or mid-update Tailscale is covered without action once it finishes coming up. Step in only if Tailscale is genuinely misconfigured — e.g. Funnel isn't enabled in your admin console; fix that and the next tick brings the funnel up (a toggle off/on forces an immediate attempt). History: the retry filter has twice been too narrow and reintroduced an HTTP-421 boot race — the phone shows "Misdirected Request" because the tunnel hostname never reaches the web-access server's DNS-rebinding allow-list. Once for not installed (before 2026-05-14) and again for the status-command failure (2026-06-24); inverting to a deny-list closes the class. See remote-access-schema-and-tunnel-boot-race postmortem.
A second HTTP-421 case — direct name+port on the tailnet (2026-08-02). Separate from the boot race: from another Tailscale device you can reach Omniscio at http://<machine>.<tailnet>.ts.net:<port>/ (over the tailnet, NOT the public Funnel). Previously only http://100.x.y.z:<port>/ passed and the name form returned 421 "Misdirected Request" — the 100.x Tailscale address is a detected NIC (added to the allow-list bare AND with the bound port), but the MagicDNS name entered it only bare (correct for the public Funnel, which terminates TLS on 443 so the browser strips the port). buildHostAllowList() (web-access-guards.ts) now also adds the <hostname>:<boundPort> variant, so name+port direct-tailnet access passes while a rebound attacker host (with or without a port) is still rejected.
Keeping the mobile launcher current
The mobile app checks the renderer build id whenever it starts or reconnects — and if a reconnect fails it keeps re-checking on a short interval, so a phone on a flaky link still finds out a newer build exists.
An open page is told too: while mobile access runs, the desktop notices within a minute that it is serving a different build and sends connected phones a "the build changed" notice over the socket they already hold. The phone runs the same realignment below — it does not poll, and the rules do not change: no card while reconnecting or offline, one card per build, never a refresh under a half-typed message.
The first build it ever sees is accepted silently — unless the phone's own cache proves the page it runs is older, in which case it realigns. That gap is real: phone storage can be emptied under the app (a full device, a cleared site), and an old page must never be recorded as current just because the record was missing. When Omniscio later serves a different build, the phone realigns:
- Not looking, nothing half-typed — it refreshes silently and your next look is the new build. It waits until the new files are completely prepared, so this is a fast start rather than a slow cold load.
- Mid-typing — it will not touch the page; instead a card says an Omniscio update is ready to load with a Reload now button. Tap it whenever you like, or leave the page a moment with the message box empty and it refreshes on its own. Only the message box you are in counts (and a pasted picture or text chip anywhere): drafts saved in other sessions come back after the refresh, so they never hold the update up. The card never appears while the phone is reconnecting or offline — it waits for the next healthy connection.
- New files cannot be prepared (a slow or interrupted connection) — it says so the same way, with the Reload now card, rather than waiting forever. Before this, a phone in that state could keep running yesterday's build for days, looking healthy, with nothing to press. The card waits about a minute and a half first, because a healthy phone is usually ready within seconds; if the files finish after the card appeared, it goes away by itself.
The card shows at most once per build on a page: close it and it stays closed, however often the phone reconnects. A newer build, or opening the app fresh, can show it again. It refreshes at most once per build, so a run of releases cannot make the page flap. A phone already running a build from before this protection needs one manual refresh (or a close-and-reopen) to receive it; every later build synchronizes on its own.
An update only counts as done once the phone can confirm the new files are what it is actually running. Before this, a phone could record a newer build it was not really on — and because its record then matched the server, it stopped checking: the "running yesterday's build while looking healthy" state, reached from the other direction. That can no longer happen; a phone that cannot confirm the files keeps asking.
To turn the whole thing off, set AMC_DISABLE_MOBILE_BUILD_UPDATE=1 — it is on by default.
The QR code won't load on my phone
First check what the popover says. If Mobile Access is running but listening only to this computer, the Scan to Connect popover no longer shows a QR code at all — it says "Your phone cannot reach this computer yet" and offers one button, Let my phone connect over Wi-Fi, which widens the listening address and restarts mobile access for you. If you see that, press the button; there is nothing else to work out.
Why this happens. Mobile Access listens on 127.0.0.1 by default — this computer only — because that keeps the port invisible to every other device on your Wi-Fi unless you ask otherwise (audit L07-F13). That default is correct for anyone reaching Omniscio through a tunnel, because tailscale serve proxies to http://127.0.0.1:<port> and so is unaffected by it. It is wrong only for plain same-Wi-Fi pairing, where the phone has to dial the computer's LAN address directly.
If you still can't connect after pressing it, the remaining suspect is the firewall. Widening the listening address is necessary but not always sufficient: Windows blocks unsolicited inbound connections, and a Wi-Fi network classified Public blocks them harder. Check for an inbound allow rule on the Mobile Access port, and consider setting a home Wi-Fi network to Private. The success message after the one-click fix says this too, for exactly this reason.
Older builds (before this fix): the popover drew a QR code for the LAN address whether or not anything was listening on it. The phone dialled an address that answered nothing, and nothing on screen suggested the cause was a setting — so the natural conclusion was that the phone, its camera, or the Wi-Fi was at fault. If someone reports "the QR code is broken" on an older build, check the bind interface first.
URL works on PC but not on phone
- Phone isn't on Tailscale: install Tailscale from the App Store / Play Store and sign in with the same account used on the PC. Mixing Google login on PC with Microsoft login on phone creates separate tailnets that can't see each other.
- Token mismatch: if the user regenerated the token in Omniscio, the old bookmarked link carries the old token and returns HTTP 401. Copy the new URL from Omniscio and re-bookmark.
- HTTPS browser warning: the public
*.ts.netURL has a real LetsEncrypt cert; a cert warning usually means the phone is hitting an old IP-only LAN URL on cellular instead of the Tailscale URL.
Page opens but stays on the loading screen
If the document itself opens but Omniscio never mounts, this is different from a dead tunnel. A cold phone boot requests many compressed JavaScript chunks at once; older builds compressed each uncached chunk synchronously, which could block the mobile listener long enough for Tailscale requests to time out. Static Brotli/Gzip cache misses now compress off the listener's event loop, so other boot requests keep moving while the cache warms. Restart Omniscio after installing the fixed build, then refresh the phone once. Do not clear browser data or regenerate the pairing token unless the page explicitly reports an authentication problem.
Phone says "Connection lost" forever, and reloading never helps (fixed 2026-09-08)
This was not a dead tunnel and not a slow boot — it was a rejected credential wearing a network error's clothes, and it was unrecoverable from the phone.
What the user saw. The phone shows "Connection lost — tap to reload". Tapping reload re-shows the same screen, forever. Nothing appears on the desktop to approve the device, because a phone is only recorded as a device after its socket authenticates — a phone that never authenticates is invisible. Measured on a real device 2026-09-07: five rejected auth attempts, an IP lockout, then a permanent dead screen.
Why it happened. Two independent faults stacked:
- The WS transport treated a
4001close (the server refusing this device's token — rotated, expired, or never valid) as the same terminal state as a dead network, so it raised the reload banner. But a reload cannot fix an auth problem. - Worse, the reload could not even reach the server: the service worker answered every top-level navigation from the cached app shell, so
/loginreturned the app instead of the sign-in page. That also silently broke the pairing QR code and the pairing link on any phone that had ever loaded the app — every route back in was dead at once.
What happens now.
- A rejected credential raises the "Pair this device" card inside the already-loaded app, with a box for the access token. It exchanges the token through the existing
POST /loginand reconnects in place — afetch, never a navigation, so nothing in the cache can defeat it. This is what rescues a phone that is already stuck (it still runs the old service worker until its cache updates). - The service worker now lets
/logingo to the network, so the QR code, the pairing link, and a hand-typed address work again for everyone. That stops new phones getting stuck. - The card accepts a pasted sign-in link as well as a bare token, since that is usually what the user has in hand.
- A wrong token, a lockout, an unreachable computer, and a server fault each get their own plain-English message, and the card stays usable so the user can retry. A genuine network drop still behaves exactly as before — this does not swallow real outages.
Contracts: mobile-pairing-rescue-contract.md (P1–P10) and mobile-service-worker-cache-contract.md (S1-serverowned).
Attaching a photo refreshes the page the first time after an update (fixed 2026-09-24)
What the user saw. Right after the desktop app restarted on a new version, the first photo attached on the phone — usually to a new session — made the page refresh and the photo vanish. Attaching again worked.
Why it happened. The phone moves itself onto a new version by reloading quietly the next time the page is hidden, on the idea that nobody is looking. But opening the photo picker also hides the page, so that one reload fired while the user was choosing a photo. The reload also brought the phone up to date, which is why the second try worked.
What happens now. A page hidden by its own photo/file picker no longer counts as "nobody is looking": the update waits and happens the next time the user actually leaves the app. The phone's diagnostic breadcrumbs also reach the desktop log again, so a case like this now leaves a trace. Contract: mobile-service-worker-cache-contract.md (S1a-picker).
Manual debug commands
Run these in a terminal on the user's PC to confirm what Omniscio is seeing — these are the exact commands Omniscio runs internally:
tailscale status --json— full status dump. InspectBackendState,Self.Online,Self.DNSName,Self.CapMap.tailscale serve status --json— what Tailscale is serving. A private entry is aWebentry for<machine>.<tailnet>.ts.net:443proxying tohttp://127.0.0.1:<port>; if the same address also appears underAllowFunnelwithtrue, it is public.- Private mode (default):
tailscale serve --bg <port>to start (replace<port>with the value in Settings → Remote Access; default9876) andtailscale serve offto stop. These are the exact commands Omniscio runs; if the start prints an enable-HTTPS prompt, HTTPS certificates are off for the tailnet. - Public mode:
tailscale funnel --bg <port>to start andtailscale funnel offto stop;tailscale funnel statuslists active funnels.
If the matching command works in a terminal but Omniscio's toggle fails, capture the stderr and check Omniscio's main log at %APPDATA%\omniscio\logs\main.log (Windows) or ~/Library/Logs/omniscio/main.log (macOS) for [tunnel-service] lines.
Token regeneration behavior
Clicking Regenerate in Settings → Remote Access asks the main process for a new token (web-access:rotate-token → rotateWebAccessToken()), which mints a fresh 256-bit token — not a UUID: generateToken() returns randomBytes(32).toString('hex') (src/main/services/web/web-access-token-auth.ts:147), unlike the initial token the renderer helper generates — saves it to config.json, re-stamps its created/last-used lifecycle times, and — if the server is currently running — stops and restarts the transport onto the new token, which drops every live phone socket immediately rather than at the next reconnect. Either way the settings panel repaints from the SETTINGS_CHANGED push, so the QR code is never stale. Old bookmarks return HTTP 401 — re-copy the URL from Omniscio.
App quit cleanup
When Omniscio quits, it releases its Tailscale entry with tailscale serve off (private) or tailscale funnel off (public), matching the mode the tunnel was started in. If the Tailscale daemon has crashed, that command can hang briefly — app quit waits up to ~10s before forcing close.
Related
- Mobile Access — the overview page this continues.
- Mobile Access part 2 — the connection behaviour that usually explains what you are seeing.
Last verified 2026-09-28