pinokiod 8.2.10 → 8.2.11

package/kernel/anywhere/localapi.js

@@ -1,147 +0,0 @@
-/*
-  Minimal client for the tailscaled LocalAPI.
-
-  tailscaled exposes an HTTP API over a unix socket (mac/linux) or a named
-  pipe (Windows). We talk to it with plain node `http` by passing the socket
-  path as `socketPath`; node's net layer handles both unix sockets and
-  `\\.\pipe\...` names. The conda-forge `tailscaled` package ships only the
-  daemon (no `tailscale` CLI), so every operation goes through this client.
-
-  Verified against tailscaled 1.104.1 (see spec/requirements/pinokio-anywhere.md):
-    GET   /localapi/v0/status                 -> ipnstate.Status JSON
-    GET   /localapi/v0/prefs                  -> ipn.Prefs JSON
-    PATCH /localapi/v0/prefs                  <- ipn.MaskedPrefs ({HostnameSet:true, Hostname:"pinokio", ...})
-    POST  /localapi/v0/login-interactive      -> 204; AuthURL shows up in /status and on the IPN bus (BrowseToURL)
-    POST  /localapi/v0/logout                 -> 204
-    GET   /localapi/v0/serve-config           -> ipn.ServeConfig JSON (or null) + Etag header
-    POST  /localapi/v0/serve-config           <- ipn.ServeConfig JSON, optional If-Match: <etag>
-    POST  /localapi/v0/query-feature?feature=serve -> {Complete, Text, URL} (URL = one-click tailnet approval)
-*/
-const http = require('http')
-
-class LocalAPIError extends Error {
-  constructor(message, status, body) {
-    super(message)
-    this.name = 'LocalAPIError'
-    this.status = status
-    this.body = body
-  }
-}
-
-class LocalAPI {
-  constructor({ socketPath, timeout = 10000 } = {}) {
-    if (!socketPath) {
-      throw new Error('LocalAPI requires a socketPath')
-    }
-    this.socketPath = socketPath
-    this.timeout = timeout
-    this.base = '/localapi/v0'
-  }
-  request(method, route, { body, headers, timeout } = {}) {
-    const payload = typeof body === 'undefined' || body === null
-      ? null
-      : (typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body))
-    const reqHeaders = Object.assign({
-      // tailscaled rejects non-loopback origins without this on some
-      // transports (the Windows GUI loopback port); harmless on sockets.
-      'Sec-Tailscale': 'localapi',
-      'Host': 'local-tailscaled.sock',
-    }, headers || {})
-    if (payload !== null) {
-      reqHeaders['Content-Type'] = reqHeaders['Content-Type'] || 'application/json'
-      reqHeaders['Content-Length'] = Buffer.byteLength(payload)
-    }
-    return new Promise((resolve, reject) => {
-      const req = http.request({
-        socketPath: this.socketPath,
-        method,
-        path: this.base + route,
-        headers: reqHeaders,
-      }, (res) => {
-        const chunks = []
-        res.on('data', (chunk) => chunks.push(chunk))
-        res.on('end', () => {
-          const text = Buffer.concat(chunks).toString('utf8')
-          resolve({
-            status: res.statusCode,
-            headers: res.headers,
-            text,
-            json: () => {
-              if (!text || !text.trim()) return null
-              return JSON.parse(text)
-            },
-          })
-        })
-        res.on('error', reject)
-      })
-      req.setTimeout(timeout || this.timeout, () => {
-        req.destroy(new Error(`LocalAPI ${method} ${route} timed out`))
-      })
-      req.on('error', reject)
-      if (payload !== null) {
-        req.write(payload)
-      }
-      req.end()
-    })
-  }
-  async expect(method, route, options, okStatuses = [200, 204]) {
-    const res = await this.request(method, route, options)
-    if (!okStatuses.includes(res.status)) {
-      throw new LocalAPIError(`LocalAPI ${method} ${route} failed: ${res.status} ${res.text.trim()}`, res.status, res.text)
-    }
-    return res
-  }
-  async status() {
-    const res = await this.expect('GET', '/status')
-    return res.json()
-  }
-  // masked: an ipn.MaskedPrefs object, e.g. { HostnameSet: true, Hostname: 'pinokio' }
-  async patchPrefs(masked) {
-    const res = await this.expect('PATCH', '/prefs', { body: masked })
-    return res.json()
-  }
-  async loginInteractive() {
-    await this.expect('POST', '/login-interactive', { body: '' })
-    return true
-  }
-  async logout() {
-    await this.expect('POST', '/logout', { body: '' })
-    return true
-  }
-  // Restarts the backend's login state machine (what `tailscale up --force-reauth`
-  // does): a stale or invalidated login URL is dropped and a fresh one is minted
-  // on the next login-interactive.
-  async start(options = {}) {
-    await this.expect('POST', '/start', { body: options })
-    return true
-  }
-  async serveConfig() {
-    const res = await this.expect('GET', '/serve-config')
-    return { config: res.json(), etag: res.headers.etag || res.headers.Etag || null }
-  }
-  async setServeConfig(config, etag) {
-    const headers = {}
-    if (etag) {
-      headers['If-Match'] = etag
-    }
-    await this.expect('POST', '/serve-config', { body: config || {}, headers })
-    return true
-  }
-  async queryFeature(feature) {
-    const res = await this.request('POST', `/query-feature?feature=${encodeURIComponent(feature)}`, { body: '' })
-    if (res.status !== 200) {
-      throw new LocalAPIError(`query-feature ${feature} failed: ${res.status} ${res.text.trim()}`, res.status, res.text)
-    }
-    return res.json()
-  }
-  async ping() {
-    try {
-      const res = await this.request('GET', '/status', { timeout: 2000 })
-      return res.status === 200
-    } catch (e) {
-      return false
-    }
-  }
-}
-
-module.exports = { LocalAPI, LocalAPIError }