pinokiod 8.2.29 → 8.2.31

package/test/anywhere-onboarding.test.js

@@ -0,0 +1,95 @@
+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 onboarding states (spec/requirements/pinokio-anywhere.md,
+// Interface > Onboarding): what the ready state shows before and after a
+// device joins, the key-expiry warning, and the approval that opens on its own.
+const filename = path.resolve(__dirname, '../server/views/anywhere.ejs')
+const template = fs.readFileSync(filename, 'utf8')
+const address = 'https://pinokio.tail123.ts.net'
+const connectUrl = 'https://pinokio.co/anywhere/connect#u=' + encodeURIComponent(address) + '&a=me%40example.com'
+const days = (n) => new Date(Date.now() + n * 86400000).toISOString()
+
+function render(t, status, agent = 'electron') {
+  const state = { status: { enabled: true, address, connectUrl, dnsName: 'pinokio.tail123.ts.net', account: { email: 'me@example.com' }, peers: [], ...status }, timers: [], opened: [] }
+  const html = ejs.render(template, { theme: 'light', agent, status: state.status }, { 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/', runScripts: 'dangerously', pretendToBeVisual: true, virtualConsole,
+    beforeParse(window) {
+      window.setTimeout = (callback, delay) => state.timers.push({ callback, delay })
+      window.fetch = async () => ({ ok: true, json: async () => ({ ...state.status }) })
+      window.open = (...args) => state.opened.push(args)
+    },
+  })
+  t.after(() => dom.window.close())
+  const document = dom.window.document
+  return { state, document, poll: () => state.timers.shift().callback(), text: (id) => document.getElementById(id).textContent }
+}
+
+test('before any device joins, the ready state is the connect card alone, with sign out', (t) => {
+  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-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')
+  assert.match(h.text('anywhere-waiting'), /Waiting for another device/)
+  assert.equal(h.document.getElementById('anywhere-expiry-warning').hidden, true)
+})
+
+test('once a device has joined, the rest of the page appears, online or not', async (t) => {
+  const h = render(t, { phase: 'ready', peers: [{ name: 'phone', os: 'iOS', online: false }] })
+  assert.equal(h.document.getElementById('anywhere-details').hidden, false)
+  assert.match(h.text('anywhere-waiting'), /No other devices are online/)
+  h.state.status.peers = []
+  h.poll(); await new Promise(setImmediate)
+  assert.equal(h.document.getElementById('anywhere-details').hidden, true, 'the page follows the payload')
+})
+
+test('a key expiring within two weeks is warned about on the desk, with the admin console link', (t) => {
+  const soon = render(t, { phase: 'ready', keyExpiry: days(10) })
+  const warning = soon.document.getElementById('anywhere-expiry-warning')
+  assert.equal(warning.hidden, false)
+  assert.match(warning.textContent, /expires .*\(in 10 days\)/)
+  assert.match(warning.textContent, /Disable key expiry for pinokio/)
+  assert.equal(warning.querySelector('a').getAttribute('href'), 'https://login.tailscale.com/admin/machines')
+  assert.equal(render(t, { phase: 'ready', keyExpiry: days(60) }).document.getElementById('anywhere-expiry-warning').hidden, true)
+  assert.equal(render(t, { phase: 'ready' }).document.getElementById('anywhere-expiry-warning').hidden, true, 'no expiry reported, no warning')
+})
+
+test('the approval opens in the external browser once per URL, without a click, and the button stays', async (t) => {
+  const approval = { url: 'https://login.tailscale.com/f/serve?node=1', text: 'Enable HTTPS certificates for your tailnet to continue.' }
+  const h = render(t, { phase: 'https', approval })
+  assert.deepEqual(h.state.opened, [[approval.url, '_blank', 'browser']])
+  assert.equal(h.document.getElementById('anywhere-approval-link').getAttribute('href'), approval.url)
+  assert.equal(h.text('anywhere-approval-text'), approval.text, "Tailscale's own text is the detail line")
+  h.poll(); await new Promise(setImmediate)
+  assert.equal(h.state.opened.length, 1, 'a poll with the same URL does not open it again')
+  assert.equal(h.document.defaultView.sessionStorage.getItem('anywhere-approval-opened'), approval.url, 'remembered for the window, so a reload does not open it again')
+  h.state.status.approval = { url: 'https://login.tailscale.com/f/serve?node=2', text: '' }
+  h.poll(); await new Promise(setImmediate)
+  assert.equal(h.state.opened.length, 2, 'a fresh approval URL opens once more')
+  assert.equal(h.text('anywhere-approval-text'), '')
+  const login = render(t, { phase: 'login', loginUrl: 'https://login.tailscale.com/a/1' })
+  assert.match(login.document.querySelector('[data-state=login]').textContent, /may be asked to approve one thing/)
+  assert.deepEqual(login.state.opened, [], 'sign-in itself still waits for the click')
+})

package/test/anywhere-others.test.js

@@ -0,0 +1,96 @@
+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/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')
+})

package/test/anywhere-peers.test.js

@@ -0,0 +1,199 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+const Server = require('../server/index.js')
+const Anywhere = require('../kernel/anywhere')
+const { buildServeConfig } = require('../kernel/anywhere/serve')
+
+// The peer routes (spec/requirements/pinokio-anywhere-api.md, Peers) and the
+// forwarded link rewrite, with the proxy request and the forwarders stubbed.
+
+const status = {
+  Self: { DNSName: 'pinokio.tail1.ts.net.' },
+  Peer: {
+    a: { HostName: 'STUDIO', DNSName: 'pinokio-1.tail1.ts.net.', OS: 'windows', Online: true, TailscaleIPs: ['100.1.1.1'] },
+    b: { HostName: 'iphone', DNSName: 'iphone-14-pro.tail1.ts.net.', OS: 'iOS', Online: true },
+    c: { HostName: 'asleep', DNSName: 'asleep.tail1.ts.net.', OS: 'macOS', Online: false },
+    d: { HostName: 'other', DNSName: 'other.tail1.ts.net.', OS: 'linux', Online: true },
+  },
+}
+
+function anywhereWith(requests = {}, { proxy = true } = {}) {
+  const anywhere = new Anywhere({})
+  anywhere.config = { enabled: true }
+  anywhere.lastStatus = status
+  anywhere.proxyPort = proxy ? 1055 : null
+  anywhere.forwarders.request = async (url, options) => {
+    const handler = requests[url]
+    if (!handler) throw new Error(`no route to ${url}`)
+    return handler(options)
+  }
+  anywhere.forwarders.open = async (dnsName, port) => 51000 + (port % 1000)
+  return anywhere
+}
+const json = (body, code = 200) => async () => ({ status: code, headers: {}, body: JSON.stringify(body) })
+const fake = (anywhere) => ({ kernel: { anywhere }, anywherePeerOpenPath: Server.prototype.anywherePeerOpenPath, anywherePeerUnavailable: Server.prototype.anywherePeerUnavailable })
+
+test('peers lists the online computers that answered a status, with apps linked through the open route', async () => {
+  const anywhere = anywhereWith({
+    'https://pinokio-1.tail1.ts.net/anywhere/status': json({ phase: 'ready', apps: [
+      { id: 'comfy', name: 'ComfyUI', state: 'ready', exposed: true, remote: 'https://pinokio-1.tail1.ts.net:43000/ui/?a=1#v' },
+      { id: 'forge', name: 'Forge', state: 'starting', exposed: false, remote: null },
+    ] }),
+    'https://other.tail1.ts.net/anywhere/status': async () => ({ status: 404, headers: {}, body: 'not pinokio' }),
+  })
+  const out = await Server.prototype.composeAnywherePeers.call(fake(anywhere))
+  assert.equal(out.status, 200)
+  assert.deepEqual(out.body, { peers: [{ name: 'pinokio-1', apps: [
+    { id: 'comfy', name: 'ComfyUI', state: 'ready', exposed: true, open: '/anywhere/peers/pinokio-1/open?port=43000&to=%2Fui%2F%3Fa%3D1%23v' },
+    { id: 'forge', name: 'Forge', state: 'starting', exposed: false, open: null },
+  ] }] })
+})
+
+test('peers skips phones and offline peers, tolerates a peer that fails, and says why while the proxy is missing', async () => {
+  const asked = []
+  const anywhere = anywhereWith({
+    'https://pinokio-1.tail1.ts.net/anywhere/status': async () => { asked.push('pinokio-1'); throw new Error('no answer in 4 s') },
+    'https://other.tail1.ts.net/anywhere/status': async () => { asked.push('other'); return { status: 200, headers: {}, body: 'not json' } },
+  })
+  assert.deepEqual((await Server.prototype.composeAnywherePeers.call(fake(anywhere))).body, { peers: [] })
+  assert.deepEqual(asked.sort(), ['other', 'pinokio-1'], 'the phone and the offline computer are never asked')
+  const adopted = anywhereWith({}, { proxy: false })
+  assert.deepEqual(await Server.prototype.composeAnywherePeers.call(fake(adopted)), { status: 502, body: { error: 'Turn Remote off and on to reach your other Pinokios' } }, 'a daemon from before the proxy existed')
+  adopted.error = 'tailscaled exited (code=1 signal=null)'
+  assert.deepEqual((await Server.prototype.composeAnywherePeers.call(fake(adopted))).body, { error: 'Remote is not running on this computer' }, 'a daemon that died')
+})
+
+test('open validates the peer, the port and the path, then redirects to the forwarder', async () => {
+  const server = fake(anywhereWith())
+  assert.equal((await Server.prototype.anywherePeerOpen.call(server, 'nobody', { port: '443' })).status, 400)
+  assert.equal((await Server.prototype.anywherePeerOpen.call(server, 'pinokio-1', { port: '8080' })).status, 400)
+  assert.equal((await Server.prototype.anywherePeerOpen.call(server, 'pinokio-1', { port: '443.5' })).status, 400)
+  const root = await Server.prototype.anywherePeerOpen.call(server, 'pinokio-1', { port: '443' })
+  assert.equal(root.status, 302)
+  assert.equal(root.headers.Location, 'http://127.0.0.1:51443/')
+  const deep = await Server.prototype.anywherePeerOpen.call(server, 'PINOKIO-1', { port: '43000', to: '/ui/?a=1#v' })
+  assert.equal(deep.headers.Location, 'http://127.0.0.1:51000/ui/?a=1#v', 'the path, query and fragment survive; the name is case-insensitive')
+  for (const bad of ['//evil.example', 'https://evil.example/', '\\\\evil.example', 'http://127.0.0.1:51443@evil.example/']) {
+    const answer = await Server.prototype.anywherePeerOpen.call(server, 'pinokio-1', { port: '443', to: bad })
+    assert.equal(new URL(answer.headers.Location).origin, 'http://127.0.0.1:51443', `a path that could leave the forwarder (${bad}) stays on it`)
+  }
+  const odd = await Server.prototype.anywherePeerOpen.call(server, 'pinokio-1', { port: '443', to: '/ui/?q=caf\u00e9 x#\u00fc' })
+  assert.equal(odd.headers.Location, 'http://127.0.0.1:51443/ui/?q=caf%C3%A9%20x#%C3%BC', 'a path with characters a header cannot carry is encoded, fragment kept')
+  const unavailable = await Server.prototype.anywherePeerOpen.call(fake(anywhereWith({}, { proxy: false })), 'pinokio-1', { port: '443' })
+  assert.deepEqual(unavailable, { status: 502, body: { error: 'Turn Remote off and on to reach your other Pinokios' } }, 'a daemon from before the proxy existed')
+})
+
+test('launch and stop relay the peer\'s status and body, turning an open URL into the open route', async () => {
+  const sent = []
+  const anywhere = anywhereWith({
+    'https://pinokio-1.tail1.ts.net/anywhere/apps/launch': async (options) => { sent.push(options); return { status: 200, headers: {}, body: JSON.stringify({ action: 'open', url: 'https://pinokio-1.tail1.ts.net:43000/' }) } },
+    'https://pinokio-1.tail1.ts.net/anywhere/apps/stop': json({ error: 'Unknown app: x' }, 400),
+  })
+  const server = fake(anywhere)
+  const launch = await Server.prototype.relayAnywherePeerAction.call(server, 'pinokio-1', 'launch', { id: 'comfy' })
+  assert.deepEqual(launch, { status: 200, body: { action: 'open', url: '/anywhere/peers/pinokio-1/open?port=43000&to=%2F' } })
+  assert.equal(sent[0].method, 'POST')
+  assert.equal(sent[0].body, '{"id":"comfy"}')
+  assert.equal(sent[0].headers['Content-Type'], 'application/json')
+  assert.deepEqual(await Server.prototype.relayAnywherePeerAction.call(server, 'pinokio-1', 'stop', { id: 'x' }), { status: 400, body: { error: 'Unknown app: x' } })
+  assert.equal((await Server.prototype.relayAnywherePeerAction.call(server, 'nobody', 'stop', {})).status, 400)
+})
+
+test('a launch whose default is an outside address passes through unchanged', async () => {
+  const anywhere = anywhereWith({
+    'https://pinokio-1.tail1.ts.net/anywhere/apps/launch': json({ action: 'open', url: 'https://github.com/x/y' }),
+  })
+  const launch = await Server.prototype.relayAnywherePeerAction.call(fake(anywhere), 'pinokio-1', 'launch', { id: 'docs' })
+  assert.deepEqual(launch.body, { action: 'open', url: 'https://github.com/x/y' })
+})
+
+test('a peer that cannot be reached or answers without JSON relays as 502', async () => {
+  const anywhere = anywhereWith({
+    'https://pinokio-1.tail1.ts.net/anywhere/apps/stop': async () => { throw new Error('no answer in 30 s') },
+    'https://other.tail1.ts.net/anywhere/apps/stop': async () => ({ status: 404, headers: {}, body: '<html>' }),
+  })
+  const server = fake(anywhere)
+  const down = await Server.prototype.relayAnywherePeerAction.call(server, 'pinokio-1', 'stop', { id: 'x' })
+  assert.equal(down.status, 502)
+  assert.match(down.body.error, /Could not reach STUDIO: no answer/)
+  const old = await Server.prototype.relayAnywherePeerAction.call(server, 'other', 'stop', { id: 'x' })
+  assert.deepEqual(old, { status: 502, body: { error: 'other did not answer with JSON (HTTP 404)' } })
+  const stopped = await Server.prototype.relayAnywherePeerAction.call(fake(anywhereWith({}, { proxy: false })), 'other', 'stop', {})
+  assert.equal(stopped.status, 502)
+})
+
+test('the peer routes answer a browser on this computer only, never a tailnet client through Serve, whatever Host it sends', () => {
+  const server = { kernel: { anywhere: anywhereWith() }, isLoopbackHost: Server.prototype.isLoopbackHost, isLocalRequest: Server.prototype.isLocalRequest }
+  const request = ({ remote = '127.0.0.1', host = 'localhost:42000', origin, headers = {} } = {}) => ({
+    socket: { remoteAddress: remote },
+    get: (name) => ({ host, origin, ...Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])) })[name.toLowerCase()],
+  })
+  const allowed = (req) => Server.prototype.anywherePeerAllowed.call(server, req)
+  assert.equal(allowed(request()), true, 'a top-level navigation on this computer')
+  assert.equal(allowed(request({ remote: '::1', host: '[::1]:42000', origin: 'http://[::1]:42000' })), true)
+  assert.equal(allowed(request({ remote: '::ffff:127.0.0.1', host: '127.0.0.1:42000', origin: 'http://127.0.0.1:42000' })), true)
+  assert.equal(allowed(request({ origin: 'http://localhost:3000' })), false, 'another local site is not this page')
+  assert.equal(allowed(request({ origin: 'https://pinokio.co' })), false)
+  assert.equal(allowed(request({ origin: 'not a url' })), false)
+  assert.equal(allowed(request({ host: 'pinokio.tail1.ts.net' })), false, 'the node\'s own name')
+  assert.equal(allowed(request({ headers: { 'X-Forwarded-For': '100.1.1.1' } })), false, 'through Serve with a forged loopback Host')
+  assert.equal(allowed(request({ headers: { 'X-Pinokio-Peer': '1', 'X-Pinokio-Source-Host': 'localhost' } })), false, 'through another Pinokio')
+  assert.equal(allowed(request({ remote: '192.168.1.5' })), false, 'Home Server on the LAN')
+  assert.equal(allowed(request({ remote: null })), false, 'no socket address at all')
+  assert.equal(Server.prototype.isLoopbackHost('LOCALHOST'), true)
+  assert.equal(Server.prototype.isLoopbackHost('localhost.evil'), false)
+})
+
+test('a live daemon is still ours across a pinokiod restart, its proxy port read from its command line', () => {
+  const anywhere = new Anywhere({ platform: 'linux', path: (...parts) => ['/home/x', ...parts].join('/'), bin: { mod: { tailscaled: { binPath: () => '/opt/tailscaled' } } } })
+  const line = (port) => ['/opt/tailscaled', ...anywhere.daemonArgs(port)].join(' ')
+  assert.equal(anywhere.proxyPort, null, 'a fresh pinokiod process knows no port yet')
+  assert.equal(anywhere.ownedPid({ pid: 7 }, line(1055)), 7)
+  assert.equal(anywhere.ownedProxyPort, 1055, 'the port the daemon was given, for adoption')
+  assert.equal(anywhere.ownedPid({ pid: 7 }, line(null)), 7, 'a daemon started before the proxy existed')
+  assert.equal(anywhere.ownedProxyPort, null, 'and it has no proxy to use')
+  assert.equal(anywhere.ownedPid({ pid: 7 }, line(1055) + ' --extra'), null, 'anything else is not ours')
+  assert.equal(anywhere.ownedPid({ pid: 7 }, '/usr/bin/tailscaled --tun=userspace-networking'), null)
+  anywhere.platform = 'win32'
+  assert.equal(anywhere.ownedPid({ pid: 9 }, `"${line(1055).toUpperCase()}"`), 9, 'Windows compares without quotes, case-insensitively')
+})
+
+test('peerFor finds a peer by the first label of its DNS name, which may differ from its displayed name', () => {
+  const anywhere = anywhereWith()
+  assert.equal(anywhere.peerFor('pinokio-1').name, 'STUDIO')
+  assert.equal(anywhere.peerFor('iphone-14-pro').mobile, true)
+  assert.equal(anywhere.peerFor('STUDIO'), null, 'the hostname is not the key')
+  assert.equal(anywhere.peerFor(''), null)
+  assert.equal(anywhere.peerFor(null), null)
+})
+
+test('a forwarded visitor gets menu links on the forwarder\'s open path; every other visitor gets today\'s links', async () => {
+  const anywhere = new Anywhere({})
+  anywhere.config = { enabled: true }
+  anywhere.lastStatus = status
+  anywhere.lastServe = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', targets: [{ listen: 43000, target: 7860 }] })
+  const href = 'http://127.0.0.1:7860/ui/?a=1#v'
+  assert.equal(anywhere.rewriteHref('pinokio.tail1.ts.net', href, true), '/.pinokio/open?port=43000&to=%2Fui%2F%3Fa%3D1%23v')
+  assert.equal(anywhere.rewriteHref('pinokio.tail1.ts.net', href), 'https://pinokio.tail1.ts.net:43000/ui/?a=1#v')
+  assert.equal(anywhere.rewriteHref('pinokio.tail1.ts.net', href, false), 'https://pinokio.tail1.ts.net:43000/ui/?a=1#v')
+  assert.equal(anywhere.rewriteHref('localhost:42000', href, true), href, 'the Host gate still applies with the header')
+  assert.equal(anywhere.rewriteHref('pinokio.tail1.ts.net', 'http://127.0.0.1:9999/', true), 'http://127.0.0.1:9999/', 'a port without a route is left alone, as today')
+  const menu = [{ href, src: href, menu: [{ href: 'https://example.com/' }] }]
+  await anywhere.rewriteMenu('pinokio.tail1.ts.net', menu, true)
+  assert.equal(menu[0].href, '/.pinokio/open?port=43000&to=%2Fui%2F%3Fa%3D1%23v')
+  assert.equal(menu[0].src, menu[0].href)
+  assert.equal(menu[0].menu[0].href, 'https://example.com/')
+})
+
+test('the daemon is started with the proxy on the port pinokiod picked, and peers carry their DNS name', () => {
+  const anywhere = new Anywhere({ platform: 'linux', path: (...parts) => ['/home/x', ...parts].join('/') })
+  anywhere.proxyPort = 1055
+  assert.ok(anywhere.daemonArgs().includes('--outbound-http-proxy-listen=127.0.0.1:1055'))
+  assert.equal(anywhere.proxyUrl(), 'http://127.0.0.1:1055')
+  anywhere.proxyPort = null
+  assert.equal(anywhere.proxyUrl(), null)
+  assert.ok(!anywhere.daemonArgs().some((arg) => arg.includes('proxy')), 'no port, no flag')
+  assert.deepEqual(anywhere.peersFrom(status).map((p) => [p.name, p.dnsName]), [
+    ['iphone-14-pro', 'iphone-14-pro.tail1.ts.net'], ['other', 'other.tail1.ts.net'], ['STUDIO', 'pinokio-1.tail1.ts.net'], ['asleep', 'asleep.tail1.ts.net'],
+  ])
+})