@linxin666/dsh-remote-web-ui 0.3.12 → 0.3.14

package/src/relay-registry.ts

@@ -0,0 +1,232 @@
+/**
+ * Relay registry client: a stable `https://<id>.dsh-market.com` origin in
+ * front of the plugin-managed quick tunnel, so a paired phone keeps one
+ * bookmark and one cookie context across `dsh web` restarts.
+ *
+ * The plugin mints an id + secret on first run and persists them per profile
+ * under `$DSH_HOME/remote-web-ui-registry/`; every tunnel (re)start
+ * re-registers the current quick URL with the market worker. Registration is
+ * best-effort: a registry outage never blocks the tunnel — the QR just falls
+ * back to the raw quick URL for that session (the pre-relay behavior).
+ */
+
+import { randomBytes } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { dshHome } from './dsh-home.ts'
+
+/** The market worker's registration endpoints (dsh-market.com edge API). */
+export const RELAY_REGISTER_URL = 'https://dsh-market.com/api/relay/register'
+export const RELAY_UNREGISTER_URL = 'https://dsh-market.com/api/relay/unregister'
+/**
+ * The public origin template: one stable single-label subdomain per
+ * registration id. Single label on purpose — Universal SSL covers exactly
+ * one subdomain level, so a two-level hostname would get no certificate.
+ */
+export const RELAY_BASE_SUFFIX = '.dsh-market.com'
+
+export const RELAY_ID_RE = /^[a-z0-9]{16}$/
+export const RELAY_SECRET_RE = /^[A-Za-z0-9_-]{43}$/
+
+/** Persisted per-profile relay identity. */
+export interface RelayIdentity {
+  id: string
+  secret: string
+  /**
+   * True only for an identity minted in this process that has never been
+   * accepted by the registry: the first register carries `new_secret` so
+   * the endpoint may create the row; refreshes authenticate with `secret`
+   * alone and must not re-claim an id that already exists.
+   */
+  fresh?: boolean
+}
+
+/** The observable relay lifecycle the settings card renders. */
+export type RelayState =
+  | { state: 'off' }
+  | { state: 'registering' }
+  | { state: 'running'; url: string }
+  | { state: 'failed'; error: string }
+
+/** Registry storage layout: one file per profile under the relay directory. */
+export function relayIdentityFile(profile: string, home: string = dshHome()): string {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profile)) {
+    throw new Error(`relay registry: profile ${JSON.stringify(profile)} is not a safe path segment`)
+  }
+  return join(home, 'remote-web-ui-registry', `${profile}.json`)
+}
+
+/** Generate one identity pair (id: 8-byte hex slug; secret: 32-byte base64url). */
+export function generateRelayIdentity(random: (size: number) => Buffer = randomBytes): RelayIdentity {
+  return {
+    id: random(8).toString('hex'),
+    secret: random(32).toString('base64url'),
+    fresh: true,
+  }
+}
+
+/**
+ * Load (or lazily mint) the per-profile relay identity. The file is written
+ * owner-only on first mint; a corrupt file is reminted (the phone then
+ * re-pairs once — the same cost as losing the devices file).
+ */
+export function loadRelayIdentity(profile: string, home: string = dshHome(), random: (size: number) => Buffer = randomBytes): RelayIdentity {
+  const file = relayIdentityFile(profile, home)
+  try {
+    if (existsSync(file)) {
+      const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<RelayIdentity>
+      if (typeof parsed.id === 'string' && RELAY_ID_RE.test(parsed.id)
+        && typeof parsed.secret === 'string' && RELAY_SECRET_RE.test(parsed.secret)) {
+        // A persisted identity has certainly been registered before.
+        return { id: parsed.id, secret: parsed.secret }
+      }
+      console.warn(`relay registry: ${file} is malformed — reminting the identity (paired devices must scan the QR once more)`)
+    }
+  } catch (error) {
+    console.warn(`relay registry: could not read ${file} (${error instanceof Error ? error.message : String(error)}) — reminting`)
+  }
+  const identity = generateRelayIdentity(random)
+  mkdirSync(dirname(file), { recursive: true })
+  writeFileSync(file, JSON.stringify({ id: identity.id, secret: identity.secret }, null, 2) + '\n', { mode: 0o600 })
+  return identity
+}
+
+/** Build the registration request body for one identity + tunnel target. */
+function registrationBody(identity: RelayIdentity, target: string): string {
+  return JSON.stringify({
+    id: identity.id,
+    secret: identity.secret,
+    new_secret: identity.fresh === true ? identity.secret : undefined,
+    target,
+  })
+}
+
+/** Best-effort removal of the mapping (used on disable; errors are swallowed). */
+export async function unregisterRelay(
+  identity: RelayIdentity,
+  endpoint: string = RELAY_UNREGISTER_URL,
+  fetchFn: typeof fetch = fetch,
+): Promise<void> {
+  await fetchFn(endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ id: identity.id, secret: identity.secret }),
+  })
+}
+
+/**
+ * The stable relay base for one identity — the origin the QR and the phone
+ * bookmark use while (or after) the registration is accepted.
+ */
+export function relayBaseOf(identity: RelayIdentity): string {
+  return `https://${identity.id}${RELAY_BASE_SUFFIX}`
+}
+
+/**
+ * Registration loop with capped exponential backoff. Re-registration happens
+ * on every tunnel start (the quick URL can change after a crash-restart);
+ * failures retry with backoff and surface the last error to the card.
+ */
+export class RelayRegistrar {
+  private timer: NodeJS.Timeout | undefined
+  private attempts = 0
+  private lastError: string | undefined
+  private disposed = false
+
+  constructor(
+    private readonly identity: RelayIdentity,
+    private readonly setState: (state: RelayState) => void,
+    private readonly options: {
+      fetchFn?: typeof fetch
+      registerUrl?: string
+      unregisterUrl?: string
+      baseDelayMs?: number
+      maxDelayMs?: number
+      timerFn?: (fn: () => void, ms: number) => NodeJS.Timeout
+    } = {},
+  ) {}
+
+  /** The stable relay base for the QR while registered. */
+  get baseUrl(): string {
+    return relayBaseOf(this.identity)
+  }
+
+  /** The last registration failure detail (undefined while healthy). */
+  get error(): string | undefined {
+    return this.lastError
+  }
+
+  /** Push one tunnel target; resolves the stable base once accepted. */
+  async announce(target: string): Promise<string | undefined> {
+    // A disposed registrar stays disposed: a pending retry timer must not
+    // resurrect it (re-enabling creates a fresh registrar instead).
+    if (this.disposed) return undefined
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    this.setState({ state: 'registering' })
+    try {
+      const fetchFn = this.options.fetchFn ?? fetch
+      const response = await fetchFn(this.options.registerUrl ?? RELAY_REGISTER_URL, {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: registrationBody(this.identity, target),
+      })
+      if (!response.ok) {
+        const detail = await response.json().catch(() => undefined)
+        const error = detail && typeof detail.error === 'string' ? detail.error : `HTTP ${String(response.status)}`
+        throw new Error(error)
+      }
+      // The row exists now: never claim a fresh id twice.
+      this.identity.fresh = false
+      this.attempts = 0
+      this.lastError = undefined
+      this.setState({ state: 'running', url: this.baseUrl })
+      return this.baseUrl
+    } catch (error) {
+      this.lastError = error instanceof Error ? error.message : String(error)
+      if (this.lastError === 'invalid-params' && this.identity.fresh !== true) {
+        // The registry lost the row (a D1 restore or manual wipe): re-claim
+        // the id with a fresh claim on the next retry. A 403 auth-failed
+        // means the id is owned by another secret and stays failed.
+        this.identity.fresh = true
+      }
+      this.setState({ state: 'failed', error: this.lastError })
+      this.scheduleRetry(target)
+      return undefined
+    }
+  }
+
+  /** Best-effort removal of the registry row (the relay toggle turned off). */
+  async unregister(): Promise<void> {
+    await unregisterRelay(this.identity, this.options.unregisterUrl, this.options.fetchFn)
+  }
+
+  private scheduleRetry(target: string): void {
+    if (this.disposed) return
+    const base = this.options.baseDelayMs ?? 5_000
+    const max = this.options.maxDelayMs ?? 60_000
+    const delay = Math.min(base * 2 ** this.attempts, max)
+    this.attempts += 1
+    const timerFn = this.options.timerFn ?? ((fn: () => void, ms: number) => {
+      const timer = setTimeout(fn, ms)
+      timer.unref?.()
+      return timer
+    })
+    this.timer = timerFn(() => {
+      this.timer = undefined
+      void this.announce(target)
+    }, delay)
+  }
+
+  /** Stop retrying and clear the card state (tunnel stopped or disabled). */
+  dispose(): void {
+    this.disposed = true
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    this.setState({ state: 'off' })
+  }
+}

package/src/remote-api.ts

@@ -39,7 +39,6 @@ import {
 } from './remote-methods.ts'
 
 export {
-  DESKTOP_LAUNCHER_PATH,
   LOCAL_ONLY_PREFIXES,
   PLUGIN_MANAGER_PATH,
   REMOTE_API_PATHS,

package/src/remote-channel-boot.ts

@@ -59,7 +59,6 @@ export function buildRemoteChannelBootScript(rules: RemoteChannelRules = REMOTE_
     'function sf(p){' +
     'if(p.indexOf(R.pairPrefix)===0)return false;' +
     'if(p.indexOf(R.updatePrefix)===0)return false;' +
-    'if(p===R.desktopLauncherPrefix||p.indexOf(R.desktopLauncherPrefix+"/")===0)return false;' +
     'if(p===R.settingsBridgePrefix||p.indexOf(R.settingsBridgePrefix+"/")===0)return false;' +
     'if(p.indexOf(R.apiPrefix)===0)return true;' +
     'if(p.indexOf(R.sidebarPrefix)===0||p==="/sidebar")return true;' +

package/src/remote-channel-rules.ts

@@ -22,7 +22,6 @@ export interface RemoteChannelRules {
   readonly apiPrefix: string
   readonly pairPrefix: string
   readonly updatePrefix: string
-  readonly desktopLauncherPrefix: string
   readonly settingsBridgePrefix: string
   readonly sidebarPrefix: string
   readonly gitPrefix: string
@@ -42,7 +41,6 @@ export const REMOTE_CHANNEL_RULES: RemoteChannelRules = {
   apiPrefix: '/api/',
   pairPrefix: '/api/pair/',
   updatePrefix: '/api/update/',
-  desktopLauncherPrefix: '/api/dsh-desktop-launcher',
   settingsBridgePrefix: '/api/dsh-web-ui-settings',
   sidebarPrefix: '/sidebar/',
   gitPrefix: '/git/',

package/src/remote-methods.ts

@@ -45,9 +45,6 @@ export const REMOTE_UPGRADE_PATHS = [
 /** Plugin-manager HTTP prefix: install/remove stay physically local. */
 export const PLUGIN_MANAGER_PATH = '/api/plugin-manager'
 
-/** Desktop-launcher HTTP prefix: shortcut create and host shutdown stay physically local. */
-export const DESKTOP_LAUNCHER_PATH = '/api/dsh-desktop-launcher'
-
 /** Family settings-bridge HTTP prefix — re-exposed to paired devices (plain settings parity). */
 export const WEB_UI_SETTINGS_BRIDGE_PATH = '/api/dsh-web-ui-settings'
 
@@ -68,14 +65,12 @@ export const REMOTE_DEVICE_QUERY = 'device'
  * paired remote desktop may use the full host API (chat, sessions,
  * settings, credentials, presets — it is a full-control credential), but it
  * must not reach the machine-control planes: pairing control itself, the
- * dsh-web self-update installer, plugin install/remove, and desktop
- * launcher actions (host shutdown, shortcuts).
+ * dsh-web self-update installer, and plugin install/remove.
  */
 export const LOCAL_ONLY_PREFIXES: readonly string[] = [
   '/api/pair',
   '/api/update',
   PLUGIN_MANAGER_PATH,
-  DESKTOP_LAUNCHER_PATH,
 ] as const
 
 /**

package/src/tunnel-plan.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure planner for the settings-sync tunnel branch: given the resolved
+ * settings slice, decide which tunnel mode runs and with what target. Kept
+ * free of cordis types so the precedence matrix is unit-testable without a
+ * host context.
+ */
+
+/** Whether a configured public base is a parseable http(s) URL with a host. */
+export function isHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value)
+    return (url.protocol === 'http:' || url.protocol === 'https:') && url.hostname !== ''
+  } catch {
+    return false
+  }
+}
+
+/** How the settings sync should drive the tunnel for one resolved value. */
+export type TunnelPlan =
+  | { mode: 'off' }
+  | { mode: 'quick'; targetUrl: string; ignored: Array<'tunnelToken' | 'publicBaseUrl'> }
+  | { mode: 'named'; token: string; publicUrl: string }
+
+/**
+ * Decide the tunnel mode and target from one resolved settings value.
+ * Precedence: the quick tunnel wins when `autoTunnel` is on (anything else
+ * configured is reported as ignored); the named tunnel runs only with a
+ * token AND a valid public hostname (the token does not carry the hostname,
+ * so the QR base and the fence trust would have no source without it);
+ * otherwise no tunnel and the manual public base applies.
+ * @param value - the resolved settings slice that drives the tunnel.
+ * @param port - the local webServer port the tunnel forwards to.
+ */
+export function tunnelPlanOf(
+  value: { autoTunnel?: boolean; tunnelToken?: string; publicBaseUrl?: string },
+  port: number,
+): TunnelPlan {
+  if (value.autoTunnel === true) {
+    const ignored: Array<'tunnelToken' | 'publicBaseUrl'> = []
+    if (value.tunnelToken !== undefined && value.tunnelToken !== '') ignored.push('tunnelToken')
+    if (value.publicBaseUrl !== undefined && value.publicBaseUrl !== '') ignored.push('publicBaseUrl')
+    return { mode: 'quick', targetUrl: `http://127.0.0.1:${String(port)}`, ignored }
+  }
+  if (value.tunnelToken !== undefined && value.tunnelToken !== '') {
+    if (value.publicBaseUrl !== undefined && isHttpUrl(value.publicBaseUrl)) {
+      return { mode: 'named', token: value.tunnelToken, publicUrl: value.publicBaseUrl }
+    }
+    return { mode: 'off' }
+  }
+  return { mode: 'off' }
+}

package/src/tunnel.ts

@@ -1,9 +1,12 @@
 /**
- * Auto-tunnel manager: spawns a Cloudflare quick tunnel (`cloudflared
- * tunnel --url <local>`) through the `cloudflared` npm package — its
- * postinstall downloads the platform binary, so no user-side tooling is
- * involved — surfaces the minted `https://xxx.trycloudflare.com` URL, and
- * restarts the process after unexpected exits with exponential backoff.
+ * Auto-tunnel manager: spawns a Cloudflare tunnel through the `cloudflared`
+ * npm package — its postinstall downloads the platform binary, so no
+ * user-side tooling is involved — surfaces the public URL, and restarts the
+ * process after unexpected exits with exponential backoff. Two modes: the
+ * accountless quick tunnel (`https://xxx.trycloudflare.com`, hostname minted
+ * per start) and an account named tunnel (`cloudflared tunnel run --token`,
+ * fixed public hostname — the mode that lets a paired phone keep its
+ * bookmark and pairing cookie across restarts).
  *
  * The cloudflared package's Tunnel is a thin spawn wrapper; this manager
  * owns the lifecycle policy (binary readiness, URL timeout, restart
@@ -13,11 +16,79 @@
  */
 
 import { existsSync } from 'node:fs'
+import { EventEmitter } from 'node:events'
 import { bin, install, Tunnel } from 'cloudflared'
 
 /** The observable tunnel lifecycle the settings/panel surfaces render. */
 export type TunnelPhase = 'stopped' | 'starting' | 'running' | 'failed'
 
+/**
+ * What the manager should run. `quick` is the accountless trycloudflare
+ * tunnel whose hostname is minted per start (and dies with the process);
+ * `named` is an account tunnel whose public hostname is fixed — the point
+ * of the named mode is that a paired phone keeps its bookmark and its
+ * pairing cookie across restarts.
+ */
+export type TunnelTarget =
+  | { kind: 'quick'; targetUrl: string; originHostHeader?: string }
+  | { kind: 'named'; token: string; publicUrl: string }
+
+/** Compare two targets for the start idempotence check. */
+function sameTarget(left: TunnelTarget | undefined, right: TunnelTarget): boolean {
+  if (left === undefined) return false
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+/** The event face the named adapter wraps (a cloudflared package Tunnel). */
+interface NamedTunnelProcess {
+  on(event: 'connected', listener: () => void): unknown
+  on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown
+  on(event: 'error', listener: (value: Error) => void): unknown
+  off(event: string, listener: (...args: any[]) => void): unknown
+  stop(): boolean
+}
+
+/**
+ * Wrap a named-tunnel process so it fits the quick-tunnel handle shape: the
+ * fixed public URL is reported through the same `url` event once the first
+ * edge connection registers (cloudflared fires `connected` per connection,
+ * so only the first is taken), and exit/error pass through. The manager's
+ * URL timeout, crash-restart backoff, and stop semantics then stay fully
+ * mode-agnostic.
+ * @param inner - the running named-tunnel process.
+ * @param publicUrl - the fixed public hostname ingress maps to this server.
+ * @returns a handle emitting `url` once the tunnel is reachable.
+ */
+export function namedTunnelHandle(inner: NamedTunnelProcess, publicUrl: string): TunnelHandle {
+  const handle = new EventEmitter() as unknown as TunnelHandle & {
+    emit(event: string, ...args: any[]): boolean
+  }
+  let registered = false
+  const onConnected = (): void => {
+    // cloudflared fires `connected` per edge connection (four on a healthy
+    // registration); the fixed URL only needs reporting once.
+    if (registered) return
+    registered = true
+    handle.emit('url', publicUrl)
+  }
+  const onExit = (code: number | null, signal: NodeJS.Signals | null): void => {
+    handle.emit('exit', code, signal)
+  }
+  const onError = (value: Error): void => {
+    handle.emit('error', value)
+  }
+  inner.on('connected', onConnected)
+  inner.on('exit', onExit)
+  inner.on('error', onError)
+  handle.stop = (): boolean => {
+    inner.off('connected', onConnected)
+    inner.off('exit', onExit)
+    inner.off('error', onError)
+    return inner.stop()
+  }
+  return handle
+}
+
 /** One tunnel status frame. */
 export interface TunnelInfo {
   phase: TunnelPhase
@@ -36,8 +107,8 @@ export interface TunnelHandle {
 
 /** Injectable seams (defaults are the real cloudflared package + node timers). */
 export interface TunnelManagerOptions {
-  /** Spawn one quick tunnel toward the local target URL. */
-  factory?: (targetUrl: string) => TunnelHandle
+  /** Spawn one tunnel process for the target (quick or named). */
+  factory?: (target: TunnelTarget) => TunnelHandle
   /** Make sure the cloudflared binary exists, downloading it when absent. */
   ensureBinary?: () => Promise<void>
   /** Wait up to this long for the tunnel URL before failing the attempt. */
@@ -56,8 +127,25 @@ async function defaultEnsureBinary(): Promise<void> {
   await install(bin)
 }
 
-/** Default factory: the cloudflared package's quick tunnel (no account). */
-function defaultFactory(targetUrl: string): TunnelHandle {
+/** The flags every tunnel mode shares (see the quick factory comment). */
+const SHARED_TUNNEL_FLAGS = { '--no-autoupdate': true, '--protocol': 'http2' } as const
+
+/**
+ * Spawn flags for one quick target. `originHostHeader` stamps the Host the
+ * local webserver sees: the plugin's phone-facing fence trusts the configured
+ * public host (the stable relay origin, Host-bound) and the harness
+ * browser-auth binds cookies to the Host authority, while the Workers relay
+ * cannot control the origin-side Host at all (fetch forces it to the URL
+ * authority) — so the connector must restamp it with the stable origin.
+ */
+export function quickTunnelFlags(originHostHeader?: string): Record<string, string | boolean> {
+  return originHostHeader === undefined
+    ? { ...SHARED_TUNNEL_FLAGS }
+    : { ...SHARED_TUNNEL_FLAGS, '--http-host-header': originHostHeader }
+}
+
+/** Default factory: the cloudflared package's quick and named tunnels. */
+function defaultFactory(target: TunnelTarget): TunnelHandle {
   // `--no-autoupdate`: the binary must never upgrade itself out from under
   // the manager (a self-updated binary would break the pinned lifecycle).
   // `--protocol http2`: the default `auto` prefers QUIC (UDP 7844), which
@@ -66,7 +154,10 @@ function defaultFactory(targetUrl: string): TunnelHandle {
   // and the auto fallback never fires on a half-open QUIC handshake. http2
   // rides TCP through the same paths reliably (verified live: auto stuck at
   // ready 0 on two fresh registrations; http2 ready immediately).
-  return Tunnel.quick(targetUrl, { '--no-autoupdate': true, '--protocol': 'http2' })
+  if (target.kind === 'quick') {
+    return Tunnel.quick(target.targetUrl, quickTunnelFlags(target.originHostHeader))
+  }
+  return namedTunnelHandle(Tunnel.withToken(target.token, { ...SHARED_TUNNEL_FLAGS }), target.publicUrl)
 }
 
 /** Node timers. */
@@ -77,7 +168,7 @@ const nodeTimer = { setTimeout, clearTimeout }
  * crash-restart backoff.
  */
 export class TunnelManager {
-  private readonly factory: (targetUrl: string) => TunnelHandle
+  private readonly factory: (target: TunnelTarget) => TunnelHandle
   private readonly ensureBinary: () => Promise<void>
   private readonly urlTimeoutMs: number
   private readonly restartBaseMs: number
@@ -87,7 +178,7 @@ export class TunnelManager {
   private phase: TunnelPhase = 'stopped'
   private url: string | undefined
   private error: string | undefined
-  private targetUrl: string | undefined
+  private target: TunnelTarget | undefined
   private handle: TunnelHandle | undefined
   private urlTimer: unknown | undefined
   private restartTimer: unknown | undefined
@@ -121,16 +212,21 @@ export class TunnelManager {
   }
 
   /**
-   * Start (or keep) a quick tunnel toward `targetUrl`. Restarting with a
-   * different target tears the old tunnel down first; restarting with the
-   * same target while running is a no-op.
-   * @param targetUrl - the local URL to expose, e.g. `http://127.0.0.1:3080`.
+   * Start (or keep) a tunnel toward `target`. Restarting with a different
+   * target tears the old tunnel down first; restarting with the same target
+   * while running is a no-op. A string is the quick mode's local target URL.
+   *
+   * In quick mode the URL surfaces when cloudflared mints the ephemeral
+   * trycloudflare hostname; in named mode the fixed `publicUrl` surfaces
+   * once the first edge connection registers (see {@link namedTunnelHandle}).
+   * @param target - what to run (a string means quick toward that local URL).
    */
-  start(targetUrl: string): void {
-    if (this.targetUrl === targetUrl && (this.phase === 'starting' || this.phase === 'running')) return
+  start(target: TunnelTarget | string): void {
+    const resolved: TunnelTarget = typeof target === 'string' ? { kind: 'quick', targetUrl: target } : target
+    if (sameTarget(this.target, resolved) && (this.phase === 'starting' || this.phase === 'running')) return
     this.teardown()
     this.stopping = false
-    this.targetUrl = targetUrl
+    this.target = resolved
     this.attempts = 0
     this.generation += 1
     this.attempt()
@@ -140,7 +236,7 @@ export class TunnelManager {
   stop(): void {
     this.teardown()
     this.stopping = false
-    this.targetUrl = undefined
+    this.target = undefined
     this.setPhase('stopped')
   }
 
@@ -162,15 +258,15 @@ export class TunnelManager {
   }
 
   private attempt(): void {
-    if (this.stopping || this.targetUrl === undefined) return
+    if (this.stopping || this.target === undefined) return
     const gen = this.generation
     this.setPhase('starting')
     this.handle = undefined
     this.url = undefined
     this.error = undefined
     void this.ensureBinary().then(() => {
-      if (this.stopping || this.targetUrl === undefined || gen !== this.generation) return
-      const handle = this.factory(this.targetUrl)
+      if (this.stopping || this.target === undefined || gen !== this.generation) return
+      const handle = this.factory(this.target)
       this.handle = handle
       this.urlTimer = this.timer.setTimeout(() => {
         // The tunnel never reported a URL: kill it and retry with backoff.
@@ -192,7 +288,7 @@ export class TunnelManager {
       })
     }).catch((value: unknown) => {
       // Binary install failed (no network, no platform build): report it.
-      if (this.stopping || this.targetUrl === undefined || gen !== this.generation) return
+      if (this.stopping || this.target === undefined || gen !== this.generation) return
       const message = value instanceof Error ? value.message : String(value)
       this.fail(`could not obtain the cloudflared binary: ${message}`)
     })