pinokiod 8.2.10 → 8.2.12

package/server/index.js

@@ -34,6 +34,7 @@ const Git = require("../kernel/git")
 const TerminalApi = require('../kernel/api/terminal')
 const PluginSources = require("../kernel/plugin_sources")
 const ManagedSkills = require("../kernel/managed_skills")
+const { rewriteHref: rewriteAnywhereHref } = require("../kernel/anywhere/serve")
 const { isPathRemovalBlockedError, removePath } = require("../kernel/path_removal")
 
 const git = require('isomorphic-git')
@@ -1024,8 +1025,6 @@ class Server {
     try {
       const parsed = new URL(value)
       if (parsed.port) return Number(parsed.port)
-      if (parsed.protocol === "https:") return 443
-      if (parsed.protocol === "http:") return 80
     } catch (_) { }
     return null
   }
@@ -1046,17 +1045,19 @@ class Server {
     let entries = []
     try {
       entries = await this.kernel.api.listApps()
-    } catch (_) { }
+    } catch (error) {
+      return Object.assign(snap, { phase: "error", error: `Could not list apps: ${error.message}` })
+    }
     snap.installed = entries.length
-    snap.apps = []
     if (snap.phase === "ready") {
       const serveByLocalPort = new Map((snap.serve || []).map((entry) => [entry.local, entry]))
       let running = []
       try {
-        running = await this.collectHomeServerApps(entries)
-      } catch (_) {
-        running = []
+        running = await this.collectHomeServerApps(entries, true)
+      } catch (error) {
+        return Object.assign(snap, { phase: "error", error: `Could not list running apps: ${error.message}` })
       }
+      snap.apps = []
       for (const app of running) {
         const port = this.portFromUrl(app.ready_url || app.url)
         const entry = port ? serveByLocalPort.get(port) : null
@@ -1064,8 +1065,8 @@ class Server {
           id: app.id,
           name: app.name,
           icon: app.icon,
-          state: app.state,
-          remote: entry ? entry.url : null,
+          state: entry ? app.state : (app.state === "ready" ? "publishing" : app.state),
+          remote: entry ? rewriteAnywhereHref(app.ready_url || app.url, snap.serve) : null,
           exposed: !!entry,
         })
       }
@@ -1083,7 +1084,7 @@ class Server {
     return snap
   }
   // `entries`: an app list from kernel.api.listApps() the caller already has
-  async collectHomeServerApps(entries = null) {
+  async collectHomeServerApps(entries = null, strict = false) {
     const apps = []
     if (!this.kernel || !this.kernel.api || typeof this.kernel.api.listApps !== "function") {
       return apps
@@ -1106,7 +1107,8 @@ class Server {
         runtime = this.appRegistry && typeof this.appRegistry.collectAppRuntime === "function"
           ? this.appRegistry.collectAppRuntime(appRoot)
           : null
-      } catch (_) {
+      } catch (error) {
+        if (strict) throw error
         runtime = null
       }
       if (!runtime || !runtime.running) {
@@ -14241,7 +14243,7 @@ class Server {
       })
     }))
     this.app.get("/anywhere", ex(async (req, res) => {
-      let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check({
+      let { install_required, requirements_pending } = await this.kernel.bin.check({
         bin: this.kernel.bin.preset("anywhere"),
       })
       if (!requirements_pending && install_required) {
@@ -14259,12 +14261,6 @@ class Server {
       const status = await this.composeAnywhereStatus()
       res.render("anywhere", {
         status,
-        requirements_pending,
-        install_required,
-        error,
-        docs: this.docs,
-        portal: this.portal,
-        logo: this.logo,
         theme: this.theme,
         agent: req.agent,
       })
@@ -14287,7 +14283,7 @@ class Server {
         return
       }
       try {
-        await fn(anywhere, req)
+        await fn(anywhere)
         res.json({ success: true, status: await this.composeAnywhereStatus() })
       } catch (error) {
         console.log(`[anywhere] ${label} failed`, error)

package/server/public/universal-launcher.js

@@ -4429,6 +4429,11 @@
       ui.intentWrap.setAttribute('aria-hidden', hasPresetIntent ? 'true' : 'false');
     }
     ui.setIntent(type);
+    // setIntent saved the cleared textarea over the draft when the intent was
+    // already selected (the default), dropping a prompt passed in defaults.
+    // Restore it as if typed, so the draft, folder name and height follow.
+    ui.promptTextarea.value = buildInitialPrompt(type, prompt);
+    ui.promptTextarea.dispatchEvent(new Event('input'));
     ui.setMode(mode);
     if (name) {
       ui.nameInput.value = name;

package/server/views/anywhere.ejs

@@ -136,7 +136,7 @@ document.addEventListener('DOMContentLoaded', function() {
         <p class='task-description'>Open this Pinokio and its running apps from your phone or another computer, anywhere, over a private encrypted network.</p>
       </div>
       <div class='task-header-actions'>
-        <div class='anywhere-switch' id='anywhere-switch' data-on='false' data-busy='false'>
+        <div class='anywhere-switch' id='anywhere-switch' data-on='false'>
           <i class="fa-solid fa-power-off"></i> <span id='anywhere-switch-label'>Off</span>
         </div>
       </div>
@@ -190,7 +190,7 @@ document.addEventListener('DOMContentLoaded', function() {
           <div class='anywhere-card'>
             <h2>Something went wrong</h2>
             <div class='anywhere-error' id='anywhere-error'></div>
-            <p><button class='anywhere-btn' data-action='start'><i class="fa-solid fa-rotate-right"></i> Try again</button></p>
+            <p><button class='anywhere-btn' id='anywhere-retry' data-action='start'><i class="fa-solid fa-rotate-right"></i> Try again</button></p>
           </div>
         </div>
 
@@ -255,7 +255,6 @@ document.addEventListener('DOMContentLoaded', function() {
   const agent = document.body.getAttribute('data-agent')
   let current = <%- JSON.stringify(status || {}).replace(/</g, '\\u003c') %>
   let busy = false
-  let timer = null
 
   const esc = (value) => String(value == null ? '' : value).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
   const openExternal = (href) => {
@@ -315,6 +314,7 @@ document.addEventListener('DOMContentLoaded', function() {
     }
     if (phase === 'error') {
       document.getElementById('anywhere-error').textContent = current.error || current.serveError || 'unknown error'
+      document.getElementById('anywhere-retry').dataset.action = current.enabled === false ? 'stop' : 'start'
     }
     if (phase === 'ready') {
       const qr = document.getElementById('anywhere-qr')
@@ -368,32 +368,32 @@ document.addEventListener('DOMContentLoaded', function() {
   const poll = async () => {
     try {
       const response = await fetch('/anywhere/status', { cache: 'no-store' })
-      if (response.ok) {
-        render(await response.json())
-      }
-    } catch (e) { }
+      if (!response.ok) throw new Error(`Could not refresh Anywhere status (${response.status})`)
+      render(await response.json())
+    } catch (e) {
+      render(Object.assign({}, current, { phase: 'error', error: e.message }))
+    }
     const phase = current.phase || ''
     const delay = (phase === 'ready' || phase === 'off') ? 5000 : 2000
-    timer = setTimeout(poll, delay)
+    setTimeout(poll, delay)
   }
 
   const act = async (action) => {
     if (busy) return
     busy = true
-    switchEl.dataset.busy = 'true'
+    const enabled = action === 'stop' ? false : action === 'start' ? true : current.enabled
     try {
       const response = await fetch(`/anywhere/${action}`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' })
       const data = await response.json()
       if (data && data.status) {
         render(data.status)
       } else if (data && data.error) {
-        render(Object.assign({}, current, { phase: 'error', error: data.error }))
+        render(Object.assign({}, current, { phase: 'error', error: data.error, enabled }))
       }
     } catch (e) {
-      render(Object.assign({}, current, { phase: 'error', error: e.message }))
+      render(Object.assign({}, current, { phase: 'error', error: e.message, enabled }))
     } finally {
       busy = false
-      switchEl.dataset.busy = 'false'
     }
   }
 
@@ -429,7 +429,7 @@ document.addEventListener('DOMContentLoaded', function() {
   })
 
   render(current)
-  timer = setTimeout(poll, 1500)
+  setTimeout(poll, 1500)
 })()
 </script>
 </body>

package/server/views/partials/main_sidebar.ejs

@@ -140,7 +140,6 @@
         badge.textContent = label;
         badge.hidden = false;
         badge.dataset.state = on ? "on" : "off";
-        tab.dataset.anywhereStatus = phase;
         tab.setAttribute("title", `Pinokio Anywhere ${label}`);
       };
       document.addEventListener("pinokio:anywhere-status", (event) => {

package/server/views/remote.ejs

@@ -50,7 +50,7 @@ h2 { font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacin
     <h2>Running now</h2>
     <div id="cards"></div>
   </section>
-  <div id="notice" class="notice" hidden><strong>Nothing is running</strong>Start an app on your computer and it shows up here.</div>
+  <div id="notice" class="notice" hidden></div>
   <a id="door" class="door" href="/home">
     <i class="fa-solid fa-plus"></i>
     <div class="body"><div class="title" id="door-title"></div><div class="cap" id="door-cap"></div></div>
@@ -66,8 +66,13 @@ h2 { font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacin
   const render = (status) => {
     current = status || {}
     const apps = Array.isArray(current.apps) ? current.apps : []
+    const available = current.phase === 'ready' && Array.isArray(current.apps)
     document.getElementById('running').hidden = apps.length === 0
     document.getElementById('notice').hidden = apps.length > 0
+    const states = { setup: 'Set up Pinokio Anywhere', off: 'Pinokio Anywhere is off', starting: 'Starting Pinokio Anywhere…', login: 'Sign in to Tailscale', machine_auth: 'Device approval required', https: 'HTTPS approval required' }
+    document.getElementById('notice').innerHTML = available
+      ? '<strong>Nothing is running</strong>Start an app on your computer and it shows up here.'
+      : `<strong>${esc(current.error || current.serveError || states[current.phase] || 'Pinokio Anywhere is unavailable')}</strong><a href="/anywhere">Open Anywhere</a>`
     document.getElementById('cards').innerHTML = apps.map((app) => `
       <div class="card">
         <img src="${esc(app.icon || '/pinokio-black.png')}" alt="">
@@ -80,13 +85,16 @@ h2 { font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacin
     const door = document.getElementById('door')
     door.className = 'door ' + (apps.length > 0 ? 'dashed' : 'solid')
     document.getElementById('door-title').textContent = apps.length > 0 ? 'Start another app' : 'Start an app'
-    document.getElementById('door-cap').textContent = `${current.installed || 0} installed apps in Pinokio`
+    document.getElementById('door-cap').textContent = typeof current.installed === 'number' ? `${current.installed} installed apps in Pinokio` : ''
   }
   const poll = async () => {
     try {
       const response = await fetch('/anywhere/status', { cache: 'no-store' })
-      if (response.ok) render(await response.json())
-    } catch (_) { }
+      if (!response.ok) throw new Error(`Could not refresh app status (${response.status})`)
+      render(await response.json())
+    } catch (error) {
+      render({ ...current, phase: 'error', error: error.message, apps: undefined })
+    }
     setTimeout(poll, 5000)
   }
   render(current)

package/system/pip_seed.json

@@ -0,0 +1,6 @@
+{
+  "version": "26.2.2",
+  "filename": "pip-26.2.2-py3-none-any.whl",
+  "url": "https://files.pythonhosted.org/packages/3f/06/3e4420302363fbb71be3c7f35ce042f54bfca330e3e66b3a2e3c4cca579f/pip-26.2.2-py3-none-any.whl",
+  "sha256": "fd7f4dfa8190e014013b9f08f3e973f4e4c26ffd179a204895533a7254813a70"
+}

package/system/repair_pip_seed.py

@@ -0,0 +1,100 @@
+"""Prepare a managed interpreter's local pip seed without changing its venvs."""
+
+import sys
+
+
+def repair(wheel_path, prefix, check=False):
+    if sys.version_info < (3, 10):
+        if check:
+            raise RuntimeError("pip seed mitigation requires Python 3.10+")
+        return
+
+    import ensurepip
+    from email.parser import BytesParser
+    import hashlib
+    import json
+    import os
+    from pathlib import Path
+    import re
+    import stat
+    import tempfile
+    import zipfile
+
+    def resolved(value):
+        return os.path.normcase(os.path.realpath(value))
+
+    prefix = resolved(prefix)
+    source = Path(ensurepip.__file__).resolve()
+    if (resolved(sys.prefix) != prefix or resolved(sys.base_prefix) != prefix
+            or os.path.commonpath([prefix, resolved(source)]) != prefix):
+        raise RuntimeError("Refusing pip seed repair outside the selected Python prefix")
+    if getattr(ensurepip, "_WHEEL_PKG_DIR", None):
+        raise RuntimeError("Unsupported external ensurepip wheel directory")
+
+    pin = json.loads(Path(__file__).with_name("pip_seed.json").read_text())
+    content = source.read_bytes()
+    match = re.search(br'^_PIP_VERSION = ["\']([^"\']+)["\']', content, re.M)
+    if not match or not re.fullmatch(br"\d+(?:\.\d+)*", match[1]):
+        raise RuntimeError("Unrecognized ensurepip version reference")
+    version = match[1].decode("ascii")
+    release = lambda value: tuple(map(int, value.split(".")))
+
+    def verified(path):
+        return hashlib.sha256(path.read_bytes()).hexdigest() == pin["sha256"]
+
+    wheel_data = Path(wheel_path).read_bytes()
+    if hashlib.sha256(wheel_data).hexdigest() != pin["sha256"]:
+        raise RuntimeError("Cached pip wheel SHA-256 verification failed")
+    bundled = source.parent / "_bundled"
+    if os.path.commonpath([prefix, resolved(bundled)]) != prefix:
+        raise RuntimeError("Refusing pip seed repair outside the selected Python prefix")
+    destination = bundled / pin["filename"]
+
+    def clear_bytecode():
+        for cache in (source.parent / "__pycache__").glob("__init__.*.pyc"):
+            cache.unlink(missing_ok=True)
+
+    if release(version) > release(pin["version"]):
+        newer = bundled / ("pip-" + version + "-py3-none-any.whl")
+        try:
+            with zipfile.ZipFile(newer) as archive:
+                metadata = BytesParser().parsebytes(archive.read("pip-" + version + ".dist-info/METADATA"))
+                valid = (metadata["Name"] == "pip" and metadata["Version"] == version
+                         and "pip/__init__.py" in archive.namelist() and archive.testzip() is None)
+        except (OSError, KeyError, zipfile.BadZipFile):
+            valid = False
+        if valid:
+            if ensurepip.version() != version:
+                if check:
+                    raise RuntimeError("Managed Python ensurepip bytecode needs repair")
+                clear_bytecode()
+            return
+    if check:
+        if version != pin["version"] or ensurepip.version() != version or not verified(destination):
+            raise RuntimeError("Managed Python pip seed needs repair")
+        return
+
+    def publish(path, data, mode):
+        descriptor, temporary = tempfile.mkstemp(dir=str(path.parent))
+        try:
+            with os.fdopen(descriptor, "wb") as handle:
+                handle.write(data)
+            os.chmod(temporary, mode)
+            os.replace(temporary, path)
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+
+    # Publish the wheel first and retain the old one if source replacement fails.
+    if not destination.is_file() or not verified(destination):
+        mode = stat.S_IMODE(destination.stat().st_mode) if destination.exists() else 0o644
+        publish(destination, wheel_data, mode)
+    updated = content[:match.start(1)] + pin["version"].encode("ascii") + content[match.end(1):]
+    if updated != content:
+        publish(source, updated, stat.S_IMODE(source.stat().st_mode))
+    if updated != content or ensurepip.version() != pin["version"]:
+        clear_bytecode()
+
+
+if __name__ == "__main__":
+    repair(sys.argv[1], sys.argv[2], "--check" in sys.argv[3:])

package/test/anywhere-remote.test.js

@@ -3,32 +3,137 @@ const path = require('node:path')
 const test = require('node:test')
 const ejs = require('ejs')
 const Server = require('../server/index.js')
+const Anywhere = require('../kernel/anywhere')
+const { buildServeConfig, describeServeConfig } = require('../kernel/anywhere/serve')
+const { JSDOM } = require('jsdom')
 
 const view = path.resolve(__dirname, '..', 'server', 'views', 'remote.ejs')
 
 // composeAnywhereStatus with its collaborators stubbed: the launcher needs the
 // installed count and each running app's id next to its remote address.
-test('anywhere status carries the installed count and each app id', async () => {
+test('anywhere status carries the installed count, app ids and complete app URLs', async () => {
+  const anywhere = new Anywhere({})
+  anywhere.config = { enabled: true }
+  anywhere.lastStatus = { Self: { DNSName: 'pinokio.tail1.ts.net.' } }
+  anywhere.lastServe = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', targets: [{ listen: 43000, target: 7860 }] })
+  anywhere.snapshot = async () => ({ phase: 'ready', dnsName: 'pinokio.tail1.ts.net', serve: describeServeConfig(anywhere.lastServe) })
+  let readyUrl
   const fake = {
     kernel: {
-      anywhere: {
-        snapshot: async () => ({ phase: 'ready', connectUrl: null, serve: [{ local: 7860, url: 'https://pinokio.tail1.ts.net:43000' }] }),
-      },
+      anywhere,
       api: { listApps: async () => [{ id: 'comfy' }, { id: 'forge' }, { id: 'idle' }] },
     },
     collectHomeServerApps: async () => [
-      { id: 'comfy', name: 'ComfyUI', icon: '/c.png', ready_url: 'http://127.0.0.1:7860', state: 'ready' },
+      { id: 'comfy', name: 'ComfyUI', icon: '/c.png', ready_url: readyUrl, state: 'ready' },
       { id: 'forge', name: 'Forge', icon: '/f.png', ready_url: '', state: 'starting' },
     ],
     portFromUrl: Server.prototype.portFromUrl,
   }
-  const status = await Server.prototype.composeAnywhereStatus.call(fake, {})
-  assert.equal(status.installed, 3)
-  assert.deepEqual(status.apps.map((a) => [a.id, a.remote]), [['comfy', 'https://pinokio.tail1.ts.net:43000'], ['forge', null]])
+  for (const [url, expected] of [
+    ['http://127.0.0.1:7860/ui/?token=keep%20me#view', 'https://pinokio.tail1.ts.net:43000/ui/?token=keep%20me#view'],
+    ['http://127.0.0.1:7860', 'https://pinokio.tail1.ts.net:43000/'],
+  ]) {
+    readyUrl = url
+    const status = await Server.prototype.composeAnywhereStatus.call(fake, {})
+    assert.equal(status.installed, 3)
+    assert.deepEqual(status.apps.map((a) => [a.id, a.remote]), [['comfy', expected], ['forge', null]])
+  }
   const light = await Server.prototype.composeAnywhereStatus.call(fake, { light: true })
   assert.equal(light.installed, undefined, 'the light status is unchanged')
 })
 
+test('remote links use captured routes when Anywhere stops during app collection', async () => {
+  for (const stage of ['list', 'runtime']) {
+    const anywhere = new Anywhere({})
+    anywhere.config = { enabled: true }
+    anywhere.lastStatus = { Self: { DNSName: 'pinokio.tail1.ts.net.' } }
+    anywhere.lastServe = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', targets: [{ listen: 43000, target: 7860 }] })
+    anywhere.snapshot = async () => ({ phase: 'ready', dnsName: 'pinokio.tail1.ts.net', serve: describeServeConfig(anywhere.lastServe) })
+    const stop = () => { anywhere.config.enabled = false; anywhere.lastServe = undefined; anywhere.lastStatus = null }
+    const fake = {
+      kernel: { anywhere, api: { listApps: async () => { if (stage === 'list') stop(); return [{ id: 'app' }] } } },
+      collectHomeServerApps: async () => {
+        if (stage === 'runtime') stop()
+        return [{ id: 'app', state: 'ready', ready_url: 'http://127.0.0.1:7860/ui/?token=keep%20me#view' }]
+      },
+      portFromUrl: Server.prototype.portFromUrl,
+    }
+    const status = await Server.prototype.composeAnywhereStatus.call(fake)
+    assert.equal(status.apps[0].remote, 'https://pinokio.tail1.ts.net:43000/ui/?token=keep%20me#view', stage)
+    assert.equal(status.apps[0].exposed, true)
+  }
+})
+
+test('unavailable app lists remain distinct from a confirmed empty list', async () => {
+  for (const phase of ['setup', 'off', 'starting', 'login', 'machine_auth', 'https', 'error']) {
+    const status = await Server.prototype.composeAnywhereStatus.call({
+      kernel: { anywhere: { snapshot: async () => ({ phase }) }, api: { listApps: async () => [] } },
+    })
+    assert.equal(status.apps, undefined, phase)
+  }
+  const failed = await Server.prototype.composeAnywhereStatus.call({
+    kernel: { anywhere: { snapshot: async () => ({ phase: 'ready' }) }, api: { listApps: async () => { throw new Error('unavailable') } } },
+  })
+  assert.equal(failed.phase, 'error')
+  assert.match(failed.error, /unavailable/)
+  assert.equal(failed.apps, undefined)
+})
+
+test('Anywhere reports runtime inspection failures while Home Server keeps its existing behavior', async () => {
+  const fake = {
+    kernel: {
+      path: (...parts) => path.join('/managed', ...parts),
+      anywhere: { snapshot: async () => ({ phase: 'ready', enabled: true, serve: [] }) },
+      api: { listApps: async () => [{ id: 'comfy', name: 'ComfyUI' }] },
+    },
+    appRegistry: { collectAppRuntime() { throw new Error('runtime inspection failed') } },
+    collectHomeServerApps: Server.prototype.collectHomeServerApps,
+    portFromUrl: Server.prototype.portFromUrl,
+  }
+  const status = await Server.prototype.composeAnywhereStatus.call(fake)
+  assert.equal(status.phase, 'error')
+  assert.match(status.error, /runtime inspection failed/)
+  assert.equal(status.apps, undefined)
+  const html = await ejs.renderFile(view, { status, theme: 'light', locals: {} })
+  const dom = new JSDOM(html, { runScripts: 'outside-only', url: 'http://localhost:42000' })
+  try {
+    dom.window.setTimeout = () => 0
+    dom.window.eval(dom.window.document.querySelector('script').textContent)
+    assert.match(dom.window.document.getElementById('notice').textContent, /runtime inspection failed/)
+    assert.doesNotMatch(dom.window.document.getElementById('notice').textContent, /Nothing is running/)
+  } finally { dom.window.close() }
+  assert.deepEqual(await fake.collectHomeServerApps(), [])
+})
+
+test('launcher renders actual states, top-level links and polling failures', async () => {
+  for (const status of [
+    { phase: 'off' }, { phase: 'setup' }, { phase: 'error', error: '<broken>' },
+    { phase: 'ready', installed: 0, apps: [] },
+    { phase: 'ready', installed: 2, apps: [
+      { id: 'comfy', name: 'Comfy', remote: 'https://pinokio.tail1.ts.net:43000' },
+      { id: 'forge', name: 'Forge', state: 'starting', remote: null },
+    ] },
+  ]) {
+    const html = await ejs.renderFile(view, { status, theme: 'light', locals: {} })
+    const dom = new JSDOM(html, { runScripts: 'outside-only', url: 'http://localhost:42000' })
+    try {
+      const timers = []
+      dom.window.setTimeout = (fn) => timers.push(fn)
+      dom.window.fetch = async () => ({ ok: false, status: 503 })
+      dom.window.eval(dom.window.document.querySelector('script').textContent)
+      const doc = dom.window.document
+      assert.equal(doc.querySelector('base').target, '_top')
+      assert.equal(doc.querySelector('#notice').textContent.includes('Nothing is running'), status.phase === 'ready')
+      assert.equal(doc.querySelectorAll('a.open').length, status.apps && status.apps.length ? 1 : 0)
+      if (status.error) assert.ok(doc.querySelector('#notice').textContent.includes('<broken>'))
+      await timers.shift()()
+      assert.equal(doc.querySelectorAll('a.open').length, 0)
+      assert.match(doc.querySelector('#notice').textContent, /503/)
+      assert.doesNotMatch(doc.querySelector('#notice').textContent, /Nothing is running/)
+    } finally { dom.window.close() }
+  }
+})
+
 test('the launcher page renders the running apps and one door to the full interface', async () => {
   const render = (status) => ejs.renderFile(view, { status, theme: 'light', locals: {} })
 
@@ -46,3 +151,72 @@ test('the launcher page renders the running apps and one door to the full interf
   assert.match(some, /"id":"forge"/)
   assert.doesNotMatch(some, /<link rel="manifest"/, 'manifest tags only for the Tailscale host')
 })
+
+test('Anywhere shows polling failures and recovers on the next successful response', async () => {
+  for (const failure of ['http', 'network']) {
+    const status = { phase: 'ready', enabled: true }
+    const html = await ejs.renderFile(path.resolve(__dirname, '..', 'server/views/anywhere.ejs'), {
+      status, theme: 'light', agent: 'browser',
+    }, { includer: () => ({ template: '' }) })
+    const dom = new JSDOM(html, { runScripts: 'outside-only', url: 'http://localhost:42000' })
+    try {
+      const timers = []
+      let requests = 0
+      dom.window.setTimeout = fn => timers.push(fn)
+      dom.window.fetch = async () => {
+        if (++requests === 1) {
+          if (failure === 'network') throw new Error('Connection failed')
+          return { ok: false, status: 503 }
+        }
+        return { ok: true, json: async () => status }
+      }
+      const { document } = dom.window
+      dom.window.eval([...document.querySelectorAll('script')].at(-1).textContent)
+      await timers.shift()()
+      assert.equal(document.getElementById('anywhere-root').dataset.phase, 'error')
+      assert.match(document.getElementById('anywhere-error').textContent, failure === 'http' ? /503/ : /Connection failed/)
+      await timers.shift()()
+      assert.equal(document.getElementById('anywhere-root').dataset.phase, 'ready')
+    } finally { dom.window.close() }
+  }
+})
+
+test('Anywhere retries the requested start or stop after API and network failures', async () => {
+  for (const action of ['start', 'stop']) {
+    for (const failure of ['saved', 'api', 'network']) {
+      const enabled = action === 'start'
+      const status = failure === 'saved'
+        ? { phase: 'error', enabled, error: 'Previous failure' }
+        : { phase: enabled ? 'off' : 'ready', enabled: !enabled }
+      const html = await ejs.renderFile(path.resolve(__dirname, '..', 'server/views/anywhere.ejs'), {
+        status, theme: 'light', agent: 'browser',
+      }, { includer: () => ({ template: '' }) })
+      const dom = new JSDOM(html, { runScripts: 'outside-only', url: 'http://localhost:42000' })
+      try {
+        const requests = []
+        const { document } = dom.window
+        dom.window.setTimeout = () => 0
+        dom.window.fetch = async (url, options) => {
+          requests.push(url)
+          assert.equal(options.method, 'POST')
+          if (requests.length === 1 && failure !== 'saved') {
+            if (failure === 'network') throw new Error('Connection failed')
+            return { json: async () => ({ error: 'Operation failed' }) }
+          }
+          return { json: async () => ({ status: { phase: enabled ? 'starting' : 'off', enabled } }) }
+        }
+        dom.window.eval([...document.querySelectorAll('script')].at(-1).textContent)
+        if (failure !== 'saved') {
+          document.getElementById('anywhere-switch').click()
+          await new Promise(setImmediate)
+          assert.equal(document.getElementById('anywhere-root').dataset.phase, 'error')
+          assert.match(document.getElementById('anywhere-error').textContent, /failed/)
+        }
+        document.getElementById('anywhere-retry').click()
+        await new Promise(setImmediate)
+        assert.deepEqual(requests, Array(failure === 'saved' ? 1 : 2).fill(`/anywhere/${action}`))
+        assert.equal(document.getElementById('anywhere-root').dataset.phase, enabled ? 'starting' : 'off')
+      } finally { dom.window.close() }
+    }
+  }
+})