pinokiod 8.2.28 → 8.2.29

package/kernel/anywhere/index.js

@@ -46,6 +46,7 @@ class Anywhere {
     this.starting = null
     this.lastStatus = null
     this.lastStatusAt = 0
+    this.statusQuery = null
     this.lastServe = undefined     // last serve config we pushed (undefined = unknown)
     this.lastServeError = null
     this.portMap = null            // app key -> stable remote port (ports.json)
@@ -53,6 +54,8 @@ class Anywhere {
     this.feature = null            // cached query-feature result
     this.featureAt = 0
     this.error = null
+    this.statusError = null
+    this.featureError = null
     this.login = null
     this.stopping = null
   }
@@ -216,6 +219,9 @@ class Anywhere {
     }
     if (this.stopping) return false
     this.error = null
+    this.statusError = null
+    this.featureError = null
+    this.statusQuery = null
     if (this.api) this.api.cancel()
     if (this.syncing) await this.syncing.catch(() => {})
     const forceLogin = !!(this.login && this.login.error)
@@ -282,7 +288,7 @@ class Anywhere {
     this.lastServeError = null
     this.lastStatusAt = 0
     const status = await this.refreshStatus(true)
-    if (!status) throw new Error(this.error)
+    if (!status) throw new Error(this.error || this.statusError || 'Could not read Tailscale status.')
     if (status.BackendState !== 'Running') this.requestLogin(forceLogin)
     return true
   }
@@ -345,6 +351,7 @@ class Anywhere {
     return inspection ? this.ownedPid(inspection, execFileSync(inspection.file, inspection.args, inspection.options)) : null
   }
   async _stop() {
+    this.statusQuery = null
     if (this.api) this.api.cancel()
     if (this.starting) await this.starting.catch(() => {})
     if (this.syncing) await this.syncing.catch(() => {})
@@ -359,6 +366,8 @@ class Anywhere {
       await sleep(100)
     }
     this.error = null
+    this.statusError = null
+    this.featureError = null
     this.lastServeError = null
     this.child = null
     this.login = null
@@ -414,10 +423,13 @@ class Anywhere {
   }
   async logout() {
     if (!(await this.assertOwnership()) || this.stopping) return false
+    this.statusQuery = null
     if (this.api) this.api.cancel()
     this.login = null
     await this.client().logout()
     this.error = null
+    this.statusError = null
+    this.featureError = null
     this.lastStatus = null
     this.lastStatusAt = 0
     this.lastServe = undefined
@@ -429,24 +441,35 @@ class Anywhere {
 
   // ---------- status ----------
   async refreshStatus(force) {
+    if (!force && this.statusQuery && this.statusQuery.api === this.api) {
+      return this.statusQuery.promise
+    }
     const now = Date.now()
     if (!force && this.lastStatus && now - this.lastStatusAt < STATUS_CACHE_MS) {
       return this.lastStatus
     }
     const api = this.client()
-    try {
-      const status = await api.status()
-      if (this.api !== api) return null
-      this.lastStatus = status
-      this.lastStatusAt = Date.now()
-      return status
-    } catch (e) {
-      if (this.api !== api) return null
-      if (!e.cancelled) this.error = e.message
-      this.lastStatus = null
-      this.lastStatusAt = Date.now()
-      return null
-    }
+    const query = { api, promise: null }
+    this.statusQuery = query
+    query.promise = (async () => {
+      try {
+        const status = await api.status()
+        if (this.api !== api || this.statusQuery !== query) return null
+        this.lastStatus = status
+        this.statusError = null
+        this.lastStatusAt = Date.now()
+        return status
+      } catch (e) {
+        if (this.api !== api || this.statusQuery !== query) return null
+        if (!e.cancelled) this.statusError = e.message
+        this.lastStatus = null
+        this.lastStatusAt = Date.now()
+        return null
+      } finally {
+        if (this.statusQuery === query) this.statusQuery = null
+      }
+    })()
+    return query.promise
   }
   dnsNameFrom(status) {
     if (!status || !status.Self || !status.Self.DNSName) return null
@@ -457,6 +480,7 @@ class Anywhere {
     if (!status || status.BackendState !== 'Running') return null
     if (Array.isArray(status.CertDomains) && status.CertDomains.length > 0) {
       this.feature = { Complete: true }
+      this.featureError = null
       return this.feature
     }
     if (this.feature && Date.now() - this.featureAt < FEATURE_QUERY_CACHE_MS) {
@@ -470,9 +494,10 @@ class Anywhere {
         })
       }
       this.feature = await this.featureQuery
+      this.featureError = null
       this.featureAt = Date.now()
     } catch (e) {
-      if (!e.cancelled) this.error = e.message
+      if (!e.cancelled) this.featureError = e.message
       this.feature = null
       this.featureAt = 0
     } finally {
@@ -600,9 +625,10 @@ class Anywhere {
     if (!Array.isArray(menu) || !this.isNodeHost(host)) return menu
     // Confirm new or changed routes on first render; refresh checks unchanged ones.
     const apps = this.appTargets()
-    if (this.syncing || this.lastServe === undefined || this.lastServeError || apps.length !== this.targets.length ||
-        apps.some((app, i) => app.key !== this.targets[i].key || app.local !== this.targets[i].local || app.origin !== this.targets[i].origin)) {
-      await this.sync()
+    const targetsChanged = apps.length !== this.targets.length ||
+      apps.some((app, i) => app.key !== this.targets[i].key || app.local !== this.targets[i].local || app.origin !== this.targets[i].origin)
+    if (this.syncing || this.lastServe === undefined || this.lastServeError || targetsChanged) {
+      await this.sync({ recheck: targetsChanged })
     }
     const rewrite = (items) => {
       for (const item of items) {
@@ -623,10 +649,10 @@ class Anywhere {
   }
   // Regenerates the Serve config from the apps' published URLs. Called from
   // kernel.refresh() (same trigger as router.update()) and after start.
-  async sync() {
-    // Concurrent callers share one operation, with a further pass for new work.
+  async sync({ recheck = true } = {}) {
+    // Reads join the pending work; only changed targets request another pass.
     if (this.syncing) {
-      this.syncAgain = true
+      if (recheck) this.syncAgain = true
       return this.syncing
     }
     this.syncing = (async () => {
@@ -707,8 +733,8 @@ class Anywhere {
     if (this.stopping || !this.config.enabled) return inactive()
     if (!status) {
       return Object.assign(base, {
-        phase: this.error ? 'error' : 'starting',
-        error: this.error,
+        phase: this.error || this.statusError ? 'error' : 'starting',
+        error: this.error || this.statusError,
         running: false,
       })
     }
@@ -761,7 +787,7 @@ class Anywhere {
     if (this.stopping || !this.config.enabled) return inactive()
     if (!feature) {
       out.phase = 'error'
-      out.error = this.error || 'Could not query HTTPS approval.'
+      out.error = this.error || this.featureError || 'Could not query HTTPS approval.'
       return out
     }
     if (!feature.Complete) {
@@ -772,10 +798,10 @@ class Anywhere {
       }
       return out
     }
-    await this.sync()
+    await this.sync({ recheck: false })
     if (this.stopping || !this.config.enabled) return inactive()
-    out.phase = this.error || this.lastServeError || this.lastServe === undefined || !this.lastStatus || this.lastStatus.BackendState !== 'Running' ? 'error' : 'ready'
-    if (out.phase === 'error') out.error = this.error || this.lastServeError || 'Routes are not confirmed'
+    out.phase = this.error || this.statusError || this.featureError || this.lastServeError || this.lastServe === undefined || !this.lastStatus || this.lastStatus.BackendState !== 'Running' ? 'error' : 'ready'
+    if (out.phase === 'error') out.error = this.error || this.statusError || this.featureError || this.lastServeError || 'Routes are not confirmed'
     out.serveError = this.lastServeError
     out.serve = describeServeConfig(this.lastServe, dnsName, Object.fromEntries(this.targets.map(target => [target.listen, target.name])))
     return out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.2.28",
+  "version": "8.2.29",
   "description": "",
   "main": "index.js",
   "scripts": {

package/test/anywhere.test.js

@@ -505,7 +505,6 @@ test('a failed HTTPS query surfaces an error instead of looping in starting', as
     assert.equal(snap.phase, 'error')
     assert.match(snap.error, /503 no netmap/)
     assert.equal(snap.approval, null)
-    anywhere.error = null
     feature = () => ({ Complete: false, Text: 'approve', URL: 'https://login.tailscale.com/f/serve?node=1' })
     anywhere.lastStatusAt = 0
     snap = await anywhere.snapshot()
@@ -1404,3 +1403,187 @@ test('cancelling a pending HTTPS approval during Stop keeps the result Off', asy
     assert.equal((await anywhere.snapshot()).approval.url, 'https://login.tailscale.com/f/fresh')
   } finally { fs.rmSync(tmp, { recursive: true, force: true }) }
 })
+
+test('a transient status failure recovers on the next snapshot without restarting Anywhere', async t => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-status-recovery-'))
+  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }))
+  const anywhere = new Anywhere(fakeKernel(tmp))
+  await anywhere.saveConfig({ enabled: true })
+  anywhere.readPid = () => 123
+  let failed = true, statusReads = 0
+  const routes = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', serverPort: 42000 })
+  anywhere.api = {
+    status: async () => {
+      statusReads++
+      if (failed) throw new Error('temporary CLI timeout')
+      return runningStatus()
+    },
+    serveConfig: async () => routes,
+    setServeConfig: async () => assert.fail('confirmed routes do not need rewriting'),
+    up: async () => assert.fail('recovery must not reauthenticate'),
+  }
+  const failure = await anywhere.snapshot()
+  assert.equal(failure.phase, 'error')
+  assert.equal(failure.error, 'temporary CLI timeout')
+  failed = false
+  const recovered = await anywhere.snapshot()
+  assert.equal(recovered.phase, 'ready')
+  assert.equal(recovered.error, null)
+  assert.equal(anywhere.statusError, null)
+  assert.equal(statusReads, 2)
+})
+
+test('successful status reads never clear a lifecycle failure', async () => {
+  const anywhere = new Anywhere(fakeKernel(os.tmpdir()))
+  anywhere.config = { enabled: true }
+  anywhere.error = 'could not stop the owned daemon'
+  anywhere.api = { status: async () => runningStatus() }
+  await anywhere.refreshStatus(true)
+  const snapshot = await anywhere.snapshot()
+  assert.equal(snapshot.phase, 'error')
+  assert.equal(snapshot.error, 'could not stop the owned daemon')
+})
+
+test('repeated status snapshots join Serve sync without extending its passes', async t => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-status-sync-'))
+  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }))
+  const anywhere = new Anywhere(fakeKernel(tmp))
+  await anywhere.saveConfig({ enabled: true })
+  anywhere.readPid = () => 123
+  anywhere.api = { status: async () => runningStatus() }
+  anywhere.lastServe = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', serverPort: 42000 })
+  let release, passes = 0
+  anywhere.pushServeConfig = async () => {
+    passes++
+    await new Promise(resolve => { release = resolve })
+    return false
+  }
+  const work = anywhere.sync()
+  // Actual target changes must still get their follow-up pass.
+  const changed = anywhere.sync()
+  const first = Array.from({ length: 6 }, () => anywhere.snapshot())
+  await new Promise(setImmediate)
+  release()
+  await new Promise(setImmediate)
+  assert.equal(passes, 2)
+  const later = Array.from({ length: 6 }, () => anywhere.snapshot())
+  await new Promise(setImmediate)
+  assert.equal(anywhere.syncAgain, false, 'polling does not queue a third pass')
+  release()
+  await Promise.all([work, changed])
+  for (const snapshot of await Promise.all([...first, ...later])) assert.equal(snapshot.phase, 'ready')
+  assert.equal(passes, 2)
+  assert.equal(anywhere.syncing, null)
+})
+
+test('unchanged menu reads join a slow Serve sync without requesting another pass', async () => {
+  const anywhere = new Anywhere(fakeKernel(os.tmpdir()))
+  anywhere.config = { enabled: true }
+  anywhere.lastStatus = runningStatus()
+  anywhere.lastServe = buildServeConfig({ dnsName: 'pinokio.tail1.ts.net', serverPort: 42000 })
+  let release, passes = 0
+  anywhere.pushServeConfig = async () => {
+    passes++
+    await new Promise(resolve => { release = resolve })
+    return false
+  }
+  const sync = anywhere.sync()
+  const menus = Array.from({ length: 10 }, () => anywhere.rewriteMenu('pinokio.tail1.ts.net', []))
+  assert.equal(anywhere.syncAgain, false)
+  release()
+  await Promise.all([sync, ...menus])
+  assert.equal(passes, 1)
+})
+
+test('startup preserves the cause of a failed initial status read and an explicit retry can recover', async t => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-start-status-'))
+  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }))
+  const anywhere = new Anywhere(fakeKernel(tmp))
+  anywhere.config = { enabled: true }
+  anywhere.readPid = () => 123
+  let failed = true
+  anywhere.api = {
+    cancel() {}, ping: async () => true, setPrefs: async () => {},
+    status: async () => {
+      if (failed) throw new Error('initial status unavailable')
+      return runningStatus()
+    },
+  }
+  await assert.rejects(anywhere.start(), /initial status unavailable/)
+  assert.equal((await anywhere.snapshot()).error, 'initial status unavailable')
+  failed = false
+  assert.equal(await anywhere.start(), true)
+  assert.equal(anywhere.error, null)
+  assert.equal(anywhere.statusError, null)
+})
+
+test('concurrent routine status reads share one CLI query and release it after success or failure', async () => {
+  const anywhere = new Anywhere(fakeKernel(os.tmpdir()))
+  let reads = 0, resolve, reject
+  anywhere.api = { status() {
+    reads++
+    return new Promise((ok, fail) => { resolve = ok; reject = fail })
+  } }
+  for (const failure of [false, true]) {
+    anywhere.lastStatusAt = 0
+    const pending = Array.from({ length: 8 }, () => anywhere.refreshStatus(false))
+    assert.equal(reads, failure ? 2 : 1, 'concurrent readers share one CLI process')
+    if (failure) reject(new Error('temporary read failure'))
+    else resolve(runningStatus())
+    const results = await Promise.all(pending)
+    assert.ok(results.every(result => failure ? result === null : result.BackendState === 'Running'))
+    assert.equal(anywhere.statusQuery, null)
+  }
+  const recovered = anywhere.refreshStatus(false)
+  resolve(runningStatus())
+  assert.equal((await recovered).BackendState, 'Running')
+  assert.equal(anywhere.statusError, null)
+})
+
+test('a forced status read supersedes older success and failure without letting their finalizers remove its query', async () => {
+  for (const oldFailure of [false, true]) {
+    const anywhere = new Anywhere(fakeKernel(os.tmpdir()))
+    const reads = []
+    anywhere.api = { status() {
+      return new Promise((resolve, reject) => reads.push({ resolve, reject }))
+    } }
+    const older = anywhere.refreshStatus(false)
+    const newer = anywhere.refreshStatus(true)
+    assert.equal(reads.length, 2, 'a forced read bypasses the pending routine query')
+    if (oldFailure) reads[0].reject(new Error('older CLI timeout'))
+    else reads[0].resolve({ BackendState: 'Stopped' })
+    assert.equal(await older, null)
+    const joining = anywhere.refreshStatus(false)
+    assert.equal(reads.length, 2, 'an old finalizer cannot drop the replacement query')
+    reads[1].resolve(runningStatus())
+    await Promise.all([newer, joining])
+    assert.equal(anywhere.lastStatus.BackendState, 'Running')
+    assert.equal(anywhere.statusError, null)
+    assert.equal(anywhere.statusQuery, null)
+    // Also check the reversed completion order: old errors must not erase recovery.
+    const late = anywhere.refreshStatus(true)
+    const latest = anywhere.refreshStatus(true)
+    reads[3].resolve(runningStatus())
+    await latest
+    if (oldFailure) reads[2].reject(new Error('late CLI timeout'))
+    else reads[2].resolve({ BackendState: 'Stopped' })
+    await late
+    assert.equal(anywhere.lastStatus.BackendState, 'Running')
+    assert.equal(anywhere.statusError, null)
+  }
+})
+
+test('a replaced CLI client has its own pending status query and ignores the former client', async () => {
+  const anywhere = new Anywhere(fakeKernel(os.tmpdir()))
+  let oldReply, newReply
+  anywhere.api = { status: () => new Promise(resolve => { oldReply = resolve }) }
+  const old = anywhere.refreshStatus(false)
+  anywhere.api = { status: () => new Promise(resolve => { newReply = resolve }) }
+  const fresh = anywhere.refreshStatus(false)
+  newReply(runningStatus())
+  await fresh
+  oldReply({ BackendState: 'Stopped' })
+  assert.equal(await old, null)
+  assert.equal(anywhere.lastStatus.BackendState, 'Running')
+  assert.equal(anywhere.statusQuery, null)
+})