pinokiod 8.2.33 → 8.2.35

package/test/anywhere-onboarding.test.js

@@ -36,22 +36,24 @@ test('before any device joins, the ready state is the connect card alone, with s
   const h = render(t, { phase: 'ready', peers: [] })
   const card = h.document.querySelector('[data-state=ready] .anywhere-card')
   assert.equal(h.document.getElementById('anywhere-details').hidden, true, 'apps, devices and details wait for a device')
-  assert.ok(card.querySelector('.anywhere-signout[data-action=logout]'), 'a wrong-account sign-in is fixable during onboarding')
+  assert.ok(h.document.querySelector('.anywhere-account-line .anywhere-signout[data-action=logout]'), 'a wrong-account sign-in is fixable during onboarding')
   assert.ok(!h.document.querySelector('#anywhere-details [data-action=logout]'), 'sign out lives with the account, not in details')
   assert.equal(card.querySelectorAll('ol, h3').length, 0, 'no step lists on the desk: the phone page explains Tailscale after the scan')
   const connect = h.document.getElementById('anywhere-connect')
-  assert.equal(connect.dataset.device, 'phone', 'the QR is the default')
-  assert.match(connect.querySelector('[data-panel=phone]').textContent, /Scan with your phone\./)
-  const computer = connect.querySelector('[data-panel=computer]')
-  assert.match(computer.textContent, /signing in as me@example.com/)
-  const choose = connect.querySelector('input[value=computer]')
-  choose.checked = true
-  choose.dispatchEvent(new h.document.defaultView.Event('change'))
-  assert.equal(connect.dataset.device, 'computer', 'the segmented control switches the panel')
-  const link = computer.querySelector('#anywhere-address')
-  assert.equal(link.getAttribute('href'), connectUrl, 'the computer path is the same link the QR carries')
-  assert.equal(link.textContent, 'pinokio.co/anywhere/connect#…', 'the fragment is not spelled out')
-  assert.equal(h.text('anywhere-account'), 'me@example.com')
+  const cards = connect.querySelectorAll('.anywhere-device-card')
+  assert.equal(cards.length, 2, 'both ways in, side by side, nothing behind a toggle')
+  for (const card of cards) {
+    const icon = card.querySelector('.anywhere-device-icon')
+    assert.ok(icon, 'each card leads with its own icon row')
+    assert.strictEqual(icon.nextElementSibling.tagName, 'H2')
+  }
+  assert.match(cards[0].textContent, /Connect a phone or tablet.*Scan with your phone\./s)
+  assert.ok(cards[0].querySelector('#anywhere-qr'))
+  assert.match(cards[1].textContent, /Connect another computer.*installing Tailscale and signing in as me@example\.com/s)
+  const link = cards[1].querySelector('#anywhere-address')
+  assert.equal(link.getAttribute('href'), connectUrl, 'the same link the QR carries')
+  assert.equal(link.textContent, 'pinokio.co/anywhere/connect#…')
+  assert.equal(h.document.querySelector('.anywhere-segments'), null)
   assert.match(h.text('anywhere-waiting'), /Waiting for another device/)
   assert.equal(h.document.getElementById('anywhere-expiry-warning').hidden, true)
 })

package/kernel/anywhere/forward.js

@@ -1,171 +0,0 @@
-/*
-  Forwarders for Remote from computer to computer
-  (spec/requirements/pinokio-anywhere.md, Other Pinokios; the routes in
-  spec/requirements/pinokio-anywhere-api.md, Peers).
-
-  The bundled tailscaled runs in userspace networking mode, so the browser on
-  this computer has no route to tailnet addresses. The daemon does, and
-  exposes it as a plain HTTP proxy on loopback (--outbound-http-proxy-listen).
-  A forwarder is one loopback port that relays HTTP requests and upgrades
-  through that proxy, with TLS to one peer's .ts.net name on one remote port.
-  The peer sees an ordinary tailnet client; the browser talks plain HTTP to
-  127.0.0.1, as it does to Pinokio itself.
-
-  Every forwarder answers /.pinokio/open itself, never relaying it: a peer on
-  this revision rewrites the links inside its interface to that path, and the
-  redirect lands on this node's `open` route, which maps the port on demand.
-*/
-const http = require('http')
-const https = require('https')
-const httpProxy = require('http-proxy')
-const { ProxyAgent } = require('proxy-agent')
-const { OPEN_PATH } = require('./serve')
-
-const FORWARDED_HEADER = 'x-pinokio-forwarded'
-// honoured by the peer middleware's trust; a forwarder never sends them
-const STRIPPED_HEADERS = ['x-pinokio-peer', 'x-pinokio-source-host', 'x-pinokio-source-proto']
-
-// This node's `open` route for a peer and port, relative for the page's links.
-function openPath(label, port, to) {
-  return `/anywhere/peers/${encodeURIComponent(label)}/open?port=${Number(port)}&to=${encodeURIComponent(to || '/')}`
-}
-
-// The headers go out as the incoming request's headers. Setting them in http-proxy's proxyReq
-// hook instead would throw: with the proxy agent the hook fires once the CONNECT completes, and
-// by then the outgoing headers are already written.
-function mark(req) {
-  for (const name of STRIPPED_HEADERS) delete req.headers[name]
-  req.headers[FORWARDED_HEADER] = '1'
-}
-
-class Forwarders {
-  // proxyUrl: () => 'http://127.0.0.1:<port>' or null while the daemon is down
-  // serverPort: () => pinokiod's own port
-  // scheme exists for the tests, which forward to a plain local server instead of
-  // TLS through the proxy; the product never passes it.
-  constructor({ proxyUrl, serverPort, scheme = 'https' } = {}) {
-    this.proxyUrl = proxyUrl
-    this.serverPort = serverPort
-    this.scheme = scheme
-    this.agents = new Map()          // proxy URL -> agent, one per daemon start
-    this.servers = new Map()         // "<dnsName>:<port>" -> { port, server, proxy, sockets } or { pending }
-  }
-  agent() {
-    const url = this.proxyUrl()
-    if (this.scheme === 'https' && !url) throw new Error('Remote is not running on this computer')
-    if (!url) return undefined
-    // proxy-agent picks CONNECT-then-TLS for an http:// proxy and an https target
-    if (!this.agents.has(url)) this.agents.set(url, new ProxyAgent({ keepAlive: true, getProxyForUrl: () => url }))
-    return this.agents.get(url)
-  }
-  // One request to a peer through the proxy, for the status probe and the launch/stop relay.
-  async request(url, options) {
-    return requestThroughProxy(this.agent(), url, options)
-  }
-  // Finds or starts the forwarder for (dnsName, port); resolves to its loopback port.
-  async open(dnsName, port) {
-    const key = `${String(dnsName).toLowerCase()}:${Number(port)}`
-    const existing = this.servers.get(key)
-    if (existing) return existing.port || (await existing.pending).port
-    const pending = this.start(dnsName, Number(port))
-    this.servers.set(key, { pending })
-    try {
-      const entry = await pending
-      this.servers.set(key, entry)
-      return entry.port
-    } catch (error) {
-      this.servers.delete(key)
-      throw error
-    }
-  }
-  async start(dnsName, port) {
-    const label = String(dnsName).split('.')[0]
-    const target = `${this.scheme}://${dnsName}:${port}`
-    const proxy = httpProxy.createProxyServer({ target, agent: this.agent(), changeOrigin: true, secure: true, ws: true })
-    proxy.on('error', (error, req, res) => {
-      const message = `Could not reach ${dnsName}: ${error && error.message ? error.message : error}`
-      if (res && typeof res.writeHead === 'function' && !res.headersSent) {
-        res.writeHead(502, { 'Content-Type': 'text/plain; charset=utf-8' })
-        res.end(message)
-      } else if (res && typeof res.destroy === 'function') {
-        res.destroy()
-      }
-    })
-    const server = http.createServer((req, res) => {
-      const url = new URL(req.url, 'http://127.0.0.1')
-      if (url.pathname === OPEN_PATH) {
-        const port = Number(url.searchParams.get('port'))
-        if (!Number.isInteger(port) || port <= 0) {
-          res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
-          res.end('Not a Remote port')
-          return
-        }
-        const route = openPath(label, port, url.searchParams.get('to') || '/')
-        res.writeHead(302, { Location: `http://127.0.0.1:${this.serverPort()}${route}`, 'Cache-Control': 'no-store' })
-        res.end()
-        return
-      }
-      mark(req)
-      proxy.web(req, res)
-    })
-    server.on('upgrade', (req, socket, head) => {
-      mark(req)
-      proxy.ws(req, socket, head)
-    })
-    // every connection on both sides, upgraded ones included, so stopAll can end a stream a
-    // tab still holds; destroying only the browser's side would leave the peer's side piped open
-    const sockets = new Set()
-    const track = (socket) => {
-      sockets.add(socket)
-      socket.once('close', () => sockets.delete(socket))
-    }
-    server.on('connection', track)
-    proxy.on('open', track)
-    await new Promise((resolve, reject) => {
-      server.once('error', reject)
-      server.listen(0, '127.0.0.1', () => { server.off('error', reject); resolve() })
-    })
-    return { port: server.address().port, server, proxy, sockets }
-  }
-  // Ends every forwarder, open streams included: they belong to the daemon that is going away.
-  async stopAll() {
-    const entries = [...this.servers.values()]
-    this.servers.clear()
-    for (const agent of this.agents.values()) if (typeof agent.destroy === 'function') agent.destroy()
-    this.agents.clear()
-    await Promise.all(entries.map(async (entry) => {
-      const live = entry.server ? entry : await entry.pending.catch(() => null)
-      if (!live) return
-      live.proxy.close()
-      for (const socket of live.sockets) socket.destroy()
-      await new Promise((resolve) => live.server.close(resolve))
-    }))
-  }
-}
-
-// Resolves { status, headers, raw, body }; rejects on a transport failure or when the whole
-// request, the proxy's CONNECT included, exceeds the deadline.
-function requestThroughProxy(agent, url, { method = 'GET', headers = {}, body = null, timeoutMs = 4000 } = {}) {
-  return new Promise((resolve, reject) => {
-    const target = new URL(url)
-    const lib = target.protocol === 'https:' ? https : http
-    // the deadline is kept here, not as the request's signal: while the agent's CONNECT is still
-    // pending the request has no socket, and Node reports an abort only once it gets one
-    const deadline = setTimeout(() => { reject(new Error(`no answer in ${Math.round(timeoutMs / 1000)} s`)); req.destroy() }, timeoutMs)
-    const req = lib.request(target, { method, headers, agent }, (res) => {
-      const chunks = []
-      res.on('data', (chunk) => chunks.push(chunk))
-      res.on('end', () => {
-        clearTimeout(deadline)
-        const raw = Buffer.concat(chunks)
-        resolve({ status: res.statusCode, headers: res.headers, raw, body: raw.toString('utf8') })
-      })
-      res.on('error', (error) => { clearTimeout(deadline); reject(error) })
-    })
-    req.on('error', (error) => { clearTimeout(deadline); reject(error) })
-    if (body != null) req.write(body)
-    req.end()
-  })
-}
-
-module.exports = { Forwarders, openPath, FORWARDED_HEADER }

package/test/anywhere-forward.test.js

@@ -1,168 +0,0 @@
-const assert = require('node:assert/strict')
-const http = require('node:http')
-const test = require('node:test')
-const { once } = require('node:events')
-const WebSocket = require('ws')
-const { Forwarders } = require('../kernel/anywhere/forward')
-
-// Forwarders (spec/requirements/pinokio-anywhere.md, Other Pinokios; the
-// API spec, Peers): one loopback port relaying to one peer and port. The
-// peer here is a plain local server, so the TLS-through-proxy layer is
-// replaced by the http scheme and no agent; what is checked is the relay.
-
-async function peer(t) {
-  const seen = []
-  const server = http.createServer((req, res) => {
-    seen.push({ url: req.url, headers: req.headers, method: req.method })
-    let body = ''
-    req.on('data', (chunk) => { body += chunk })
-    req.on('end', () => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ url: req.url, host: req.headers.host, forwarded: req.headers['x-pinokio-forwarded'] || null, peer: req.headers['x-pinokio-peer'] || null, body }))
-    })
-  })
-  const wss = new WebSocket.Server({ server })
-  wss.on('connection', (socket, req) => {
-    socket.on('message', (message) => socket.send(`echo:${message} forwarded=${req.headers['x-pinokio-forwarded'] || 'none'} peer=${req.headers['x-pinokio-peer'] || 'none'}`))
-  })
-  server.listen(0, '127.0.0.1')
-  await once(server, 'listening')
-  t.after(() => new Promise((resolve) => { wss.close(); server.close(resolve); server.closeAllConnections() }))
-  return { port: server.address().port, seen }
-}
-
-const get = (port, path, headers = {}) => new Promise((resolve, reject) => {
-  http.get({ host: '127.0.0.1', port, path, headers }, (res) => {
-    let body = ''
-    res.on('data', (chunk) => { body += chunk })
-    res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body }))
-  }).on('error', reject)
-})
-
-test('a forwarder relays requests with the forwarded header, the peer as Host, and no trusted peer headers', async (t) => {
-  const target = await peer(t)
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  t.after(() => forwarders.stopAll())
-  const local = await forwarders.open('127.0.0.1', target.port)
-  assert.equal(await forwarders.open('127.0.0.1', target.port), local, 'the same peer and port reuse the forwarder')
-  const answer = await get(local, '/ui/?a=1', { 'X-Pinokio-Peer': '1', 'X-Pinokio-Source-Host': 'evil', 'X-Pinokio-Source-Proto': 'https' })
-  assert.equal(answer.status, 200)
-  const body = JSON.parse(answer.body)
-  assert.equal(body.url, '/ui/?a=1')
-  assert.equal(body.host, `127.0.0.1:${target.port}`, 'Host names the peer, not the loopback port')
-  assert.equal(body.forwarded, '1')
-  assert.equal(body.peer, null, 'the existing peer-trust headers never pass through')
-  assert.equal(target.seen[0].headers['x-pinokio-source-host'], undefined)
-})
-
-// A forward proxy for plain http targets: the real ProxyAgent sends it absolute URLs, and
-// connects asynchronously, which is what broke the proxyReq-hook version in production.
-async function forwardProxy(t) {
-  const server = http.createServer((req, res) => {
-    const target = new URL(req.url)
-    const upstream = http.request({ host: target.hostname, port: target.port, path: target.pathname + target.search, method: req.method, headers: req.headers }, (answer) => {
-      res.writeHead(answer.statusCode, answer.headers)
-      answer.pipe(res)
-    })
-    upstream.on('error', (error) => { res.writeHead(502); res.end(error.message) })
-    req.pipe(upstream)
-  })
-  server.listen(0, '127.0.0.1')
-  await once(server, 'listening')
-  t.after(() => { server.closeAllConnections(); server.close() })
-  return `http://127.0.0.1:${server.address().port}`
-}
-
-test('through the real proxy agent, whose connection completes later, the forwarded header still goes out and nothing throws', async (t) => {
-  const target = await peer(t)
-  const proxyUrl = await forwardProxy(t)
-  const forwarders = new Forwarders({ proxyUrl: () => proxyUrl, serverPort: () => 42000, scheme: 'http' })
-  t.after(() => forwarders.stopAll())
-  const local = await forwarders.open('127.0.0.1', target.port)
-  const answer = await get(local, '/ui/?a=1', { 'X-Pinokio-Peer': '1' })
-  assert.equal(answer.status, 200)
-  const body = JSON.parse(answer.body)
-  assert.equal(body.forwarded, '1')
-  assert.equal(body.peer, null)
-  assert.equal(body.host, `127.0.0.1:${target.port}`)
-  assert.equal(target.seen.length, 1)
-})
-
-test('two opens of the same peer and port at once share one forwarder', async (t) => {
-  const target = await peer(t)
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  t.after(() => forwarders.stopAll())
-  const [a, b] = await Promise.all([forwarders.open('127.0.0.1', target.port), forwarders.open('127.0.0.1', target.port)])
-  assert.ok(Number.isInteger(a) && a > 0)
-  assert.equal(a, b)
-})
-
-test('a forwarder answers /.pinokio/open itself with a redirect to this node\'s open route', async (t) => {
-  const target = await peer(t)
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  t.after(() => forwarders.stopAll())
-  const local = await forwarders.open('pinokio-1.tail1.ts.net', target.port)
-  const answer = await get(local, '/.pinokio/open?port=43001&to=%2Fui%2F%3Fa%3D1%23view')
-  assert.equal(answer.status, 302)
-  assert.equal(answer.headers.location, 'http://127.0.0.1:42000/anywhere/peers/pinokio-1/open?port=43001&to=%2Fui%2F%3Fa%3D1%23view')
-  assert.equal((await get(local, '/.pinokio/open?to=%2F')).status, 400, 'a link without a port does not bounce through pinokiod')
-  assert.equal(target.seen.length, 0, 'never relayed')
-})
-
-test('a forwarder relays a WebSocket upgrade', async (t) => {
-  const target = await peer(t)
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  t.after(() => forwarders.stopAll())
-  const local = await forwarders.open('127.0.0.1', target.port)
-  const socket = new WebSocket(`ws://127.0.0.1:${local}/socket`, { headers: { 'X-Pinokio-Peer': '1' } })
-  await once(socket, 'open')
-  socket.send('hi')
-  const [message] = await once(socket, 'message')
-  assert.equal(String(message), 'echo:hi forwarded=1 peer=none', 'the forwarded header is added and the trust header dropped on the upgrade path too')
-  socket.close()
-})
-
-test('a peer that cannot be reached answers 502, and stopAll closes every forwarder, an open WebSocket included', async (t) => {
-  const target = await peer(t)
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  const dead = await forwarders.open('127.0.0.1', 1)
-  const answer = await get(dead, '/')
-  assert.equal(answer.status, 502)
-  assert.match(answer.body, /Could not reach 127\.0\.0\.1/)
-  const live = await forwarders.open('127.0.0.1', target.port)
-  const socket = new WebSocket(`ws://127.0.0.1:${live}/socket`)
-  await once(socket, 'open')
-  const closed = once(socket, 'close')
-  const stopped = forwarders.stopAll()
-  await Promise.race([stopped, new Promise((_, reject) => setTimeout(() => reject(new Error('stopAll hung on the open WebSocket')), 2000))])
-  await closed
-  await assert.rejects(get(live, '/'), /ECONNREFUSED/)
-})
-
-test('the https scheme refuses to forward while the daemon is down', () => {
-  const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000 })
-  assert.throws(() => forwarders.agent(), /Remote is not running/)
-})
-
-test('a request to a peer returns status and body, and the deadline covers the connection itself', async (t) => {
-  const target = await peer(t)
-  const plain = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })
-  const answer = await plain.request(`http://127.0.0.1:${target.port}/anywhere/status`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{"id":"x"}' })
-  assert.equal(answer.status, 200)
-  assert.equal(JSON.parse(answer.body).body, '{"id":"x"}')
-  const silent = http.createServer(() => { /* never answers */ })
-  silent.listen(0, '127.0.0.1')
-  await once(silent, 'listening')
-  t.after(() => { silent.closeAllConnections(); silent.close() })
-  await assert.rejects(plain.request(`http://127.0.0.1:${silent.address().port}/`, { timeoutMs: 200 }), /no answer in 0 s/)
-  // a proxy that accepts and never answers the CONNECT, through the real agent: the deadline
-  // still fires there, where a socket timeout would not have started yet
-  const held = []
-  const stuckProxy = require('node:net').createServer((socket) => { held.push(socket) /* never answers */ })
-  stuckProxy.listen(0, '127.0.0.1')
-  await once(stuckProxy, 'listening')
-  t.after(() => { for (const socket of held) socket.destroy(); stuckProxy.close() })
-  const forwarders = new Forwarders({ proxyUrl: () => `http://127.0.0.1:${stuckProxy.address().port}`, serverPort: () => 42000 })
-  t.after(() => forwarders.stopAll())
-  await assert.rejects(forwarders.request('https://peer.tail1.ts.net/anywhere/status', { timeoutMs: 300 }), /no answer in 0 s/)
-})

package/test/anywhere-others.test.js

@@ -1,96 +0,0 @@
-const assert = require('node:assert/strict')
-const fs = require('node:fs')
-const path = require('node:path')
-const test = require('node:test')
-const ejs = require('ejs')
-const { JSDOM, VirtualConsole } = require('jsdom')
-
-// The Remote page's "Your other Pinokios" section (spec/requirements/
-// pinokio-anywhere.md, Other Pinokios): on a loopback host only, filled from
-// /anywhere/peers at each status poll while ready, stop relayed per app.
-const filename = path.resolve(__dirname, '../server/views/anywhere.ejs')
-const template = fs.readFileSync(filename, 'utf8')
-const address = 'https://pinokio.tail123.ts.net'
-const ready = { phase: 'ready', enabled: true, address, connectUrl: 'https://pinokio.co/anywhere/connect#u=x', dnsName: 'pinokio.tail123.ts.net', account: { email: 'me@example.com' }, peers: [{ name: 'STUDIO', os: 'windows', online: true }], apps: [], serve: [] }
-
-function render(t, { loopback, peers }) {
-  const state = { calls: [], timers: [], peers }
-  const html = ejs.render(template, { theme: 'light', agent: 'electron', status: ready, loopback }, { filename, includer: () => ({ template: ' ' }) })
-  const virtualConsole = new VirtualConsole()
-  virtualConsole.on('jsdomError', (error) => { throw error })
-  const dom = new JSDOM(html, {
-    url: 'http://127.0.0.1:42000/anywhere', runScripts: 'dangerously', pretendToBeVisual: true, virtualConsole,
-    beforeParse(window) {
-      window.setTimeout = (callback, delay) => state.timers.push({ callback, delay })
-      window.fetch = async (url, options = {}) => {
-        state.calls.push({ url, method: options.method || 'GET', body: options.body })
-        if (url === '/anywhere/status') return { ok: true, json: async () => ({ ...ready }) }
-        if (url === '/anywhere/peers') return state.peersError ? { ok: false, status: 502, json: async () => ({ error: state.peersError }) } : { ok: true, json: async () => ({ peers: state.peers }) }
-        if (state.stopFails) return { ok: false, status: 502, json: async () => ({ error: 'no answer in 30 s' }) }
-        return { ok: true, json: async () => ({ action: 'stopped' }) }
-      }
-      window.open = () => {}
-    },
-  })
-  t.after(() => dom.window.close())
-  const document = dom.window.document
-  // the poll: status, then the peers refresh it starts; let both settle
-  const poll = async () => { state.timers.shift().callback(); await new Promise((resolve) => setImmediate(resolve)); await new Promise((resolve) => setImmediate(resolve)) }
-  return { state, document, poll, section: () => document.getElementById('anywhere-others') }
-}
-
-test('on a loopback host the section lists each other Pinokio with Open Pinokio and its apps through the open route', async (t) => {
-  const h = render(t, { loopback: true, peers: [
-    { name: 'pinokio-1', apps: [
-      { id: 'comfy', name: 'ComfyUI', state: 'ready', exposed: true, open: '/anywhere/peers/pinokio-1/open?port=43000&to=%2F' },
-      { id: 'forge', name: 'Forge', state: 'starting', exposed: false, open: null },
-    ] },
-    { name: 'other', apps: [] },
-  ] })
-  assert.ok(h.section(), 'the card exists before the first answer')
-  await h.poll()
-  assert.deepEqual(h.state.calls.map((call) => call.url), ['/anywhere/peers', '/anywhere/status', '/anywhere/peers'], 'once on load, then with each status poll')
-  const rows = [...h.section().querySelectorAll('[data-peer]')]
-  assert.deepEqual(rows.map((row) => row.dataset.peer), ['pinokio-1', 'other'])
-  const links = [...rows[0].querySelectorAll('a')].map((a) => [a.textContent, a.getAttribute('href')])
-  assert.deepEqual(links, [['Open Pinokio', '/anywhere/peers/pinokio-1/open?port=443&to=%2F'], ['Open', '/anywhere/peers/pinokio-1/open?port=43000&to=%2F']])
-  assert.match(rows[0].textContent, /Forge/)
-  assert.ok(rows[0].querySelector('.anywhere-badge'), 'an app without an address shows its state instead of a link')
-  assert.match(rows[1].textContent, /no app running/)
-  assert.doesNotMatch(h.section().textContent, /Looking…/)
-})
-
-test('with none found the section says so, and a stop is relayed to the peer then refreshed', async (t) => {
-  const h = render(t, { loopback: true, peers: [] })
-  await h.poll()
-  assert.match(h.section().textContent, /No other Pinokio with Remote on is online/)
-  h.state.peers = [{ name: 'pinokio-1', apps: [{ id: 'comfy', name: 'ComfyUI', state: 'ready', exposed: true, open: '/anywhere/peers/pinokio-1/open?port=43000&to=%2F' }] }]
-  await h.poll()
-  const stop = h.section().querySelector('button[data-stop="comfy"]')
-  assert.ok(stop)
-  stop.click()
-  await new Promise((resolve) => setImmediate(resolve)); await new Promise((resolve) => setImmediate(resolve))
-  const posted = h.state.calls.find((call) => call.method === 'POST')
-  assert.deepEqual([posted.url, posted.body], ['/anywhere/peers/pinokio-1/anywhere/apps/stop', '{"id":"comfy"}'])
-  assert.equal(h.state.calls.filter((call) => call.url === '/anywhere/peers').length, 4, 'load, two polls, and once more after the stop')
-  assert.equal(h.section().querySelector('.anywhere-error'), null)
-  h.state.stopFails = true
-  h.section().querySelector('button[data-stop="comfy"]').click()
-  await new Promise((resolve) => setImmediate(resolve)); await new Promise((resolve) => setImmediate(resolve))
-  assert.match(h.section().querySelector('.anywhere-error').textContent, /Could not stop it on pinokio-1: no answer in 30 s/)
-  assert.ok(h.section().querySelector('[data-peer="pinokio-1"]'), 'the list is still there under the note')
-})
-
-test('while the daemon runs without the proxy, the section shows the reason the server gives', async (t) => {
-  const h = render(t, { loopback: true, peers: [] })
-  h.state.peersError = 'Turn Remote off and on to reach your other Pinokios'
-  await h.poll()
-  assert.match(h.section().textContent, /Could not look for other Pinokios: Turn Remote off and on to reach your other Pinokios/)
-})
-
-test('through the node\'s own Tailscale name there is no section and no peers request', async (t) => {
-  const h = render(t, { loopback: false, peers: [{ name: 'pinokio-1', apps: [] }] })
-  assert.equal(h.section(), null)
-  await h.poll()
-  assert.deepEqual(h.state.calls.map((call) => call.url), ['/anywhere/status'], 'no peers request at load or at the poll')
-})