mindwire 0.1.34 → 0.1.36

package/dist/{chunk-3QFDSYKC.js → chunk-RTGZDLSG.js}

@@ -1,12 +1,12 @@
-import { MindwireError, TimeoutError, ApiError, RunFailedError } from './chunk-T6TD76UA.js';
+import { MindwireError, binaryCacheDirectory, cachedExecutable, verifyReleaseBytes, cacheExecutable, executableChecksum, TimeoutError, ApiError, RunFailedError } from './chunk-PFYKJ6LX.js';
 import { execFile, spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import { readFile } from 'fs/promises';
+import * as fs2 from 'fs/promises';
+import { readFile, open, rm, mkdtemp, writeFile } from 'fs/promises';
 import { promisify } from 'util';
 import { setTimeout as setTimeout$1 } from 'timers/promises';
 import { randomUUID } from 'crypto';
-import { homedir, networkInterfaces } from 'os';
-import * as path from 'path';
+import { tmpdir, homedir, networkInterfaces } from 'os';
+import * as path4 from 'path';
 
 // src/computer.ts
 var ComputerApi = class {
@@ -17,8 +17,17 @@ var ComputerApi = class {
   info() {
     return this.client.http.request("GET", "/computer");
   }
-  setRoutes(routes) {
-    return this.client.http.request("PUT", "/computer/routes", { body: { routes } });
+  discovery() {
+    return this.client.http.request("GET", "/computer/discovery");
+  }
+  configureDiscovery(enabled, url) {
+    return this.client.http.request("PUT", "/computer/discovery", { body: { enabled, url } });
+  }
+  directoryEnrollment(url, challenge) {
+    return this.client.http.request("POST", "/computer/discovery/enrollment", { body: { url, challenge } });
+  }
+  setRoutes(routes, connection) {
+    return this.client.http.request("PUT", "/computer/routes", { body: { routes, connection } });
   }
   updateStatus() {
     return this.client.http.request("GET", "/computer/update");
@@ -79,7 +88,7 @@ function computerPairingURI(invitation) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.34" ;
+var SDK_VERSION = "0.1.36" ;
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -117,12 +126,12 @@ async function ensureDaemonBinary(opts = {}) {
   if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
     throw new MindwireError(`mindwire: cannot download daemon for non-release SDK version ${version}`);
   }
-  const path2 = await import('path');
-  const { binaryCacheDirectory, cachedExecutable, cacheExecutable } = await import('./binary-cache-VM7VHCEU.js');
-  const dir = path2.join(opts.cacheDir ?? await binaryCacheDirectory(daemonPlatform), version, `${daemonPlatform}-${daemonArch}`);
+  const path5 = await import('path');
+  const { binaryCacheDirectory: binaryCacheDirectory2, cachedExecutable: cachedExecutable2, cacheExecutable: cacheExecutable2 } = await import('./binary-cache-CG52TXCZ.js');
+  const dir = path5.join(opts.cacheDir ?? await binaryCacheDirectory2(daemonPlatform), version, `${daemonPlatform}-${daemonArch}`);
   const asset = assetName(version, daemonPlatform, daemonArch);
-  const bin = path2.join(dir, asset);
-  const cached = await cachedExecutable(bin);
+  const bin = path5.join(dir, asset);
+  const cached = await cachedExecutable2(bin);
   if (cached) return cached;
   const base = (opts.releaseBaseUrl ?? proc.process?.env?.MINDWIRE_RELEASE_BASE_URL ?? "https://github.com/oblien/mindwire/releases/download").replace(/\/$/, "");
   const release = `${base}/v${version}`;
@@ -145,7 +154,7 @@ async function ensureDaemonBinary(opts = {}) {
   const expected = checksumFor(await checksums.text(), asset);
   if (!expected) throw new MindwireError(`mindwire: release v${version} has no checksum for ${asset}`);
   const bytes = new Uint8Array(await binary.arrayBuffer());
-  return cacheExecutable(bin, bytes, expected);
+  return cacheExecutable2(bin, bytes, expected);
 }
 var execute = promisify(execFile);
 function processAlive(pid) {
@@ -215,7 +224,7 @@ async function ownChild(child) {
   const alive = () => child.exitCode === null && child.signalCode === null;
   return { pid, identity, alive, async close() {
     if (!alive()) return;
-    const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+    const exited = new Promise((resolve3) => child.once("exit", () => resolve3()));
     child.kill("SIGTERM");
     const timer = setTimeout(() => {
       if (alive()) child.kill("SIGKILL");
@@ -240,6 +249,413 @@ async function adoptProcess(identity) {
     if (await matches()) process.kill(identity.pid, "SIGKILL");
   } };
 }
+var RelayOutput = class _RelayOutput {
+  constructor(file, handle) {
+    this.file = file;
+    this.handle = handle;
+  }
+  file;
+  handle;
+  position = 0;
+  timer;
+  pending = Promise.resolve();
+  closing;
+  static async create(directory = tmpdir()) {
+    const file = path4.join(directory, `.relay-output-${randomUUID()}.log`);
+    return new _RelayOutput(file, await open(file, "ax+", 384));
+  }
+  static async adopt(directory, file) {
+    if (path4.dirname(file) !== path4.resolve(directory) || !/^\.relay-output-[a-f0-9-]{36}\.log$/.test(path4.basename(file))) return;
+    try {
+      const output = new _RelayOutput(file, await open(file, "r+"));
+      output.discard();
+      return output;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  get fd() {
+    return this.handle.fd;
+  }
+  async read() {
+    const { size } = await this.handle.stat();
+    if (size > 2 * 1024 * 1024) throw new Error("The tunnel helper produced too much startup output. Check its configuration.");
+    const data = Buffer.alloc(Math.min(65536, Math.max(0, size - this.position)));
+    const { bytesRead } = await this.handle.read(data, 0, data.length, this.position);
+    this.position += bytesRead;
+    return data.subarray(0, bytesRead);
+  }
+  discard() {
+    if (this.timer || this.closing) return;
+    const drain = () => {
+      this.pending = this.pending.then(() => this.handle.truncate(0)).catch(() => {
+      });
+    };
+    drain();
+    this.timer = setInterval(drain, 2e3);
+    this.timer.unref();
+  }
+  close() {
+    return this.closing ??= (async () => {
+      clearInterval(this.timer);
+      await this.pending;
+      await this.handle.close();
+      await rm(this.file, { force: true });
+    })();
+  }
+};
+
+// src/computer/provider-errors.ts
+var ProviderConnectionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ProviderConnectionError";
+  }
+  code;
+};
+function providerNeedsAction(code) {
+  return ["provider_sign_in", "provider_limit", "provider_missing", "provider_certificate", "provider_configuration"].includes(code ?? "");
+}
+function hasCertificateError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let current = error; current && typeof current === "object" && seen.size < 8 && !seen.has(current); ) {
+    seen.add(current);
+    const value = current;
+    if ([
+      "CERT_HAS_EXPIRED",
+      "CERT_NOT_YET_VALID",
+      "ERR_TLS_CERT_ALTNAME_INVALID",
+      "DEPTH_ZERO_SELF_SIGNED_CERT",
+      "SELF_SIGNED_CERT_IN_CHAIN",
+      "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+      "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+      "CERT_REVOKED"
+    ].includes(value.code ?? "") || /certificate (?:has expired|expired|verify failed)|self[- ]signed certificate|CERT_HAS_EXPIRED/i.test(value.message ?? "")) return true;
+    current = value.cause;
+  }
+  return false;
+}
+function providerFailure(error, provider) {
+  if (error instanceof ProviderConnectionError) return error;
+  const value = error;
+  const setup = `mindwire connection ${provider.toLowerCase()}`;
+  if (hasCertificateError(error)) return new ProviderConnectionError(
+    "provider_certificate",
+    `${provider}'s TLS certificate could not be verified. The tunnel provider must fix its certificate; also check this computer's date and time. Your saved phone keys are unchanged.`
+  );
+  if (value?.code === "provider_sign_in" || [401, 403].includes(value?.status ?? 0) || /unexpected server response: (?:401|403)\b/i.test(value?.message ?? "")) {
+    return new ProviderConnectionError("provider_sign_in", `Sign in to ${provider} again with ${setup}. Your saved phone keys are unchanged.`);
+  }
+  if (value?.status === 402) return new ProviderConnectionError("provider_limit", `${provider}'s tunnel allowance was reached. Check your plan in its dashboard or choose another provider.`);
+  if (value?.status === 404) return new ProviderConnectionError("provider_missing", `This computer's ${provider} tunnel was removed. Run ${setup} to configure it again.`);
+  if (value?.status === 400 || value?.code === "provider_configuration") return new ProviderConnectionError("provider_configuration", `${provider}'s connection settings are incomplete or invalid. Run ${setup} to configure it again.`);
+  return new ProviderConnectionError("provider_connection", `${provider} couldn't connect. Check internet access and the provider account, then run ${setup}.`);
+}
+var CLOUDFLARED_VERSION = "2026.9.3";
+var execute2 = promisify(execFile);
+async function ensureCloudflareBinary(options = {}) {
+  const platform = options.platform ?? process.platform, arch = options.arch ?? process.arch;
+  const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : "";
+  if (!cpu || !["darwin", "linux", "win32"].includes(platform) || platform === "win32" && cpu !== "amd64") {
+    throw new Error("Install cloudflared for this computer, or select another connection provider.");
+  }
+  const asset = `cloudflared-${platform === "win32" ? "windows" : platform}-${cpu}${platform === "darwin" ? ".tgz" : platform === "win32" ? ".exe" : ""}`;
+  const bin = path4.join(
+    options.cacheDir ?? await binaryCacheDirectory(),
+    "cloudflared",
+    CLOUDFLARED_VERSION,
+    `${platform}-${arch}`,
+    platform === "win32" ? "cloudflared.exe" : "cloudflared"
+  );
+  const cached = await cachedExecutable(bin);
+  if (cached) return cached;
+  await options.onProgress?.("Downloading the secure connection helper\u2026");
+  const request = options.fetch ?? fetch;
+  const release = await request(
+    `https://api.github.com/repos/cloudflare/cloudflared/releases/tags/${CLOUDFLARED_VERSION}`,
+    { headers: { Accept: "application/vnd.github+json" }, signal: AbortSignal.timeout(2e4) }
+  );
+  if (!release.ok) throw new Error("Couldn't download the connection helper. Retry, install cloudflared yourself, or choose another provider.");
+  const metadata = await release.json();
+  const item = metadata.assets?.find((value) => value.name === asset);
+  const checksum = item?.digest?.match(/^sha256:([a-f0-9]{64})$/i)?.[1];
+  const expectedURL = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${asset}`;
+  if (!checksum || item?.browser_download_url !== expectedURL) throw new Error("The connection helper has no verified release asset for this computer.");
+  const downloaded = await request(expectedURL, { signal: AbortSignal.timeout(12e4) });
+  if (!downloaded.ok) throw new Error("Couldn't download the connection helper. Check your internet connection and retry.");
+  const archive = new Uint8Array(await downloaded.arrayBuffer());
+  await verifyReleaseBytes(archive, checksum, asset);
+  let executable = archive;
+  if (platform === "darwin") {
+    const temporary = await mkdtemp(path4.join(tmpdir(), "mindwire-cloudflared-"));
+    try {
+      const archivePath = path4.join(temporary, asset);
+      await writeFile(archivePath, archive, { mode: 384 });
+      const result = await execute2(
+        "/usr/bin/tar",
+        ["-xzOf", archivePath, "cloudflared"],
+        { encoding: "buffer", maxBuffer: 128 * 1024 * 1024, timeout: 3e4 }
+      );
+      executable = new Uint8Array(result.stdout);
+    } finally {
+      await rm(temporary, { recursive: true, force: true });
+    }
+  }
+  return cacheExecutable(bin, executable, await executableChecksum(executable));
+}
+async function cloudflareCommand(options) {
+  try {
+    await execute2("cloudflared", ["--version"], { timeout: 3e3, windowsHide: true });
+    return "cloudflared";
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new Error("The installed cloudflared could not start. Repair it or choose another connection provider.");
+    return ensureCloudflareBinary(options);
+  }
+}
+
+// src/computer/relay.ts
+async function adoptRelay(owner, route, directory, outputFile, configFile) {
+  const output = outputFile ? await RelayOutput.adopt(directory, outputFile) : void 0;
+  const ownedConfig = configFile && path4.dirname(configFile) === path4.resolve(directory) && /^\.relay-config-[a-f0-9-]{36}\.json$/.test(path4.basename(configFile)) ? configFile : void 0;
+  return {
+    route,
+    owner,
+    outputFile: output?.file,
+    configFile: ownedConfig,
+    async close() {
+      await owner.close();
+      await output?.close();
+      if (ownedConfig) await fs2.rm(ownedConfig, { force: true });
+    }
+  };
+}
+function websocketURL(value) {
+  const url = new URL(value);
+  if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "wss:" || !url.hostname || url.username || url.password || url.hash) {
+    throw new Error("Relay URLs must use wss:// with no embedded credentials or fragment.");
+  }
+  if (!url.pathname || url.pathname === "/") url.pathname = "/ssh";
+  return url.toString();
+}
+function validateRelayOptions(options) {
+  if (options.url) websocketURL(options.url);
+  if (options.kind === "custom" && !options.url) throw new Error("A custom relay needs --relay-url wss://your-host/ssh.");
+  if (options.kind === "oblien" && (!options.url || !options.oblienCredentialsFile || !Number.isSafeInteger(options.oblienTunnelId) || options.oblienTunnelId < 1)) {
+    throw new Error("Oblien setup is incomplete. Run mindwire connection oblien.");
+  }
+  if (options.kind === "cloudflare") {
+    const named = !!options.cloudflareTokenFile || !!options.cloudflareCredentialsFile && !!options.cloudflareTunnelId;
+    if (named && !options.url || options.url && !named) throw new Error("A named Cloudflare tunnel needs its hostname and credentials. Run mindwire connection cloudflare.");
+    if (options.cloudflareTokenFile && options.cloudflareCredentialsFile) throw new Error("Choose one Cloudflare tunnel credential source.");
+  }
+  if (options.kind === "ngrok" && options.ngrokTokenFile && !options.url) throw new Error("ngrok needs a reserved domain. Run mindwire connection ngrok.");
+}
+async function startRelay(options, port, runtime = {}) {
+  runtime.signal?.throwIfAborted();
+  validateRelayOptions(options);
+  if (options.kind === "none") return { close() {
+  } };
+  if (options.kind === "custom") {
+    if (!options.url) throw new Error("A custom relay needs --relay-url wss://your-host/ssh.");
+    return { route: { kind: "websocket", url: websocketURL(options.url) }, close() {
+    } };
+  }
+  const origin = `http://127.0.0.1:${port}`;
+  const env = { ...process.env };
+  let configFile;
+  const managed = options.kind === "oblien" || options.kind === "ngrok" && !!options.ngrokTokenFile;
+  let command, args;
+  if (managed) {
+    if (!runtime.cliPath || !runtime.outputDirectory) throw new Error("The managed relay needs its connection controller.");
+    configFile = path4.join(runtime.outputDirectory, `.relay-config-${randomUUID()}.json`);
+    await fs2.writeFile(configFile, JSON.stringify({ options, port }), { mode: 384 });
+    command = process.execPath;
+    args = [runtime.cliPath, "_relay", "--relay-config", configFile];
+    await runtime.onProgress?.(`Connecting through ${options.kind === "oblien" ? "Oblien" : "ngrok"}\u2026`);
+  } else if (options.kind === "cloudflare") {
+    command = await cloudflareCommand(runtime);
+    await runtime.onProgress?.("Connecting through Cloudflare\u2026");
+    if (options.cloudflareCredentialsFile && options.cloudflareTunnelId) {
+      if (!options.url || !runtime.outputDirectory) throw new Error("Named Cloudflare tunnel setup is incomplete.");
+      configFile = path4.join(runtime.outputDirectory, `.relay-config-${randomUUID()}.json`);
+      await fs2.writeFile(configFile, JSON.stringify({
+        tunnel: options.cloudflareTunnelId,
+        "credentials-file": options.cloudflareCredentialsFile,
+        ingress: [{ hostname: new URL(websocketURL(options.url)).hostname, service: origin }, { service: "http_status:404" }]
+      }), { mode: 384 });
+      args = ["tunnel", "--config", configFile, "--no-autoupdate", "run"];
+    } else if (options.cloudflareTokenFile) {
+      if (!options.url) throw new Error("A named Cloudflare tunnel needs --relay-url for its configured hostname.");
+      env.TUNNEL_TOKEN = (await readFile(options.cloudflareTokenFile, "utf8")).trim();
+      args = ["tunnel", "--no-autoupdate", "run"];
+    } else {
+      if (options.url) throw new Error("Use --cloudflare-token-file with a named tunnel, or --relay custom for an existing tunnel.");
+      args = ["tunnel", "--no-autoupdate", "--url", origin];
+    }
+  } else {
+    command = "ngrok";
+    args = ["http", origin, "--log", "stdout", "--log-format", "json"];
+    if (options.url) {
+      const url = new URL(websocketURL(options.url));
+      args.push("--url", `https://${url.host}`);
+    }
+  }
+  runtime.signal?.throwIfAborted();
+  const output = await RelayOutput.create(runtime.outputDirectory);
+  const child = spawn(command, args, { env, detached: true, stdio: ["ignore", output.fd, output.fd], windowsHide: true });
+  let failure;
+  child.on("error", (error) => {
+    failure = error;
+  });
+  let owner;
+  try {
+    await new Promise((resolve3, reject) => {
+      child.once("spawn", resolve3);
+      child.once("error", reject);
+    });
+    owner = await ownChild(child);
+    await runtime.onSpawn?.(owner, output.file, configFile);
+    const deadline = Date.now() + 45e3;
+    let buffer = "", cloudflareAddress = options.url, cloudflareConnected = false;
+    while (Date.now() < deadline) {
+      runtime.signal?.throwIfAborted();
+      if (failure) throw new Error(`Could not run ${options.kind}. Check its installation.`, { cause: failure });
+      const received = buffer + (await output.read()).toString();
+      buffer = received.slice(-16384);
+      let found;
+      if (!managed && options.kind === "cloudflare") {
+        cloudflareAddress ??= received.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/)?.[0];
+        cloudflareConnected ||= /Registered tunnel connection/.test(received);
+        if (cloudflareConnected) found = cloudflareAddress;
+      } else {
+        for (const line of received.split(/\r?\n/)) {
+          try {
+            const event = JSON.parse(line);
+            if (managed && event.event === "relay_error") failure = new ProviderConnectionError(
+              providerNeedsAction(event.code) ? event.code : "provider_connection",
+              event.message ?? "The provider couldn't connect."
+            );
+            if (managed && event.event === "relay_ready") found = event.url;
+            if (event.msg === "started tunnel" && event.url?.startsWith("https://")) found = event.url;
+          } catch {
+          }
+        }
+      }
+      if (found) {
+        const route = { kind: "websocket", url: websocketURL(found) };
+        output.discard();
+        const provider = owner;
+        return {
+          route,
+          process: child,
+          owner,
+          outputFile: output.file,
+          configFile,
+          async close() {
+            await provider.close();
+            await output.close();
+            if (configFile) await fs2.rm(configFile, { force: true });
+          }
+        };
+      }
+      if (failure) throw failure;
+      if (!owner.alive()) throw new Error(`${options.kind} exited before the tunnel connected. Check its account configuration.`);
+      await setTimeout$1(50, void 0, { signal: runtime.signal });
+    }
+    throw new Error(`${options.kind} did not establish its tunnel. Check your internet connection and its configuration.`);
+  } catch (error) {
+    if (owner) await owner.close();
+    else if (child.pid) await (await ownChild(child)).close();
+    await output.close();
+    if (configFile) await fs2.rm(configFile, { force: true });
+    throw error;
+  }
+}
+async function acquireProcessLock(file, options = {}) {
+  const owner = await currentProcessIdentity();
+  const queue = file + ".queue", id = randomUUID() + ".json", claimPath = queue + "/" + id;
+  await fs2.mkdir(queue, { recursive: true, mode: 448 });
+  let lock;
+  const release = async () => {
+    try {
+      if (lock) {
+        const held = lock;
+        lock = void 0;
+        const owned = await held.stat();
+        await held.close();
+        const current = await fs2.stat(file).catch(() => void 0);
+        if (current?.ino === owned.ino && current.dev === owned.dev) await fs2.rm(file, { force: true });
+      }
+    } finally {
+      await fs2.rm(claimPath, { force: true });
+    }
+  };
+  const publish = async (claim) => {
+    const temporary = claimPath + ".tmp";
+    try {
+      await fs2.writeFile(temporary, JSON.stringify(claim), { mode: 384 });
+      await fs2.rename(temporary, claimPath);
+    } finally {
+      await fs2.rm(temporary, { force: true });
+    }
+  };
+  const claims = async () => {
+    const entries = [];
+    for (const candidate of await fs2.readdir(queue)) {
+      if (!candidate.endsWith(".json")) continue;
+      const content = await fs2.readFile(queue + "/" + candidate, "utf8").catch((error) => {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      });
+      if (content === void 0) continue;
+      const claim = JSON.parse(content);
+      if (!claim.owner || claim.ticket !== null && (!Number.isSafeInteger(claim.ticket) || claim.ticket < 1)) {
+        throw new Error("Invalid Mindwire lock ticket.");
+      }
+      if (await processStateAlive(claim.owner)) entries.push({ id: candidate, claim });
+      else await fs2.rm(queue + "/" + candidate, { force: true });
+    }
+    return entries;
+  };
+  try {
+    options.signal?.throwIfAborted();
+    await publish({ owner, ticket: null });
+    const ticket = Math.max(0, ...(await claims()).map((entry) => entry.claim.ticket ?? 0)) + 1;
+    if (!Number.isSafeInteger(ticket)) throw new Error("Mindwire's connection queue is full. Retry shortly.");
+    await publish({ owner, ticket });
+    const deadline = Date.now() + 3e4;
+    while (Date.now() < deadline) {
+      options.signal?.throwIfAborted();
+      if (await options.onWait?.()) {
+        await release();
+        return void 0;
+      }
+      const ahead = (await claims()).some((entry) => entry.id !== id && (entry.claim.ticket === null || entry.claim.ticket < ticket || entry.claim.ticket === ticket && entry.id < id));
+      if (!ahead) {
+        try {
+          lock = await fs2.open(file, "wx", 384);
+          await lock.writeFile(JSON.stringify(owner));
+          return { close: release };
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+          const holder = await readProcessState(file);
+          const age = Date.now() - (await fs2.stat(file).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+          if (age > 5e3 && !await processStateAlive(holder)) {
+            await fs2.rm(file, { force: true });
+            continue;
+          }
+        }
+      }
+      await setTimeout$1(250, void 0, { signal: options.signal });
+    }
+    throw new Error("Another Mindwire operation is in progress. Try again shortly.");
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
 
 // src/http.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -287,13 +703,13 @@ var Http = class {
    * SDK error instead of a bare `TypeError: fetch failed`. An abort (the request's own signal, or
    * our timeout controller) is re-thrown untouched — `fetchWithTimeout` classifies it.
    */
-  async fetchOnce(f, url, init, method, path2) {
+  async fetchOnce(f, url, init, method, path5) {
     try {
       return await f(url, init);
     } catch (e) {
       const aborted = init.signal?.aborted ?? false;
       if (aborted || isAbortError(e)) throw e;
-      throw new MindwireError(`mindwire: ${method} ${path2} \u2014 network request failed`, { cause: e });
+      throw new MindwireError(`mindwire: ${method} ${path5} \u2014 network request failed`, { cause: e });
     }
   }
   /**
@@ -302,9 +718,9 @@ var Http = class {
    * `timeoutMs`; whichever aborts first wins. Timeout → {@link TimeoutError}; the caller's own abort
    * propagates as-is (its `reason`). `timeoutMs<=0` disables the deadline entirely.
    */
-  async fetchWithTimeout(f, url, init, userSignal, method, path2) {
+  async fetchWithTimeout(f, url, init, userSignal, method, path5) {
     if (!this.timeoutMs || this.timeoutMs <= 0) {
-      return this.fetchOnce(f, url, { ...init, ...userSignal ? { signal: userSignal } : {} }, method, path2);
+      return this.fetchOnce(f, url, { ...init, ...userSignal ? { signal: userSignal } : {} }, method, path5);
     }
     const ctrl = new AbortController();
     const onAbort = () => ctrl.abort(userSignal?.reason);
@@ -318,9 +734,9 @@ var Http = class {
       ctrl.abort();
     }, this.timeoutMs);
     try {
-      return await this.fetchOnce(f, url, { ...init, signal: ctrl.signal }, method, path2);
+      return await this.fetchOnce(f, url, { ...init, signal: ctrl.signal }, method, path5);
     } catch (e) {
-      if (timedOut) throw new TimeoutError(method, path2, this.timeoutMs);
+      if (timedOut) throw new TimeoutError(method, path5, this.timeoutMs);
       if (userSignal?.aborted) throw userSignal.reason ?? e;
       throw e;
     } finally {
@@ -359,8 +775,8 @@ var Http = class {
   async ready() {
     await this.base();
   }
-  url(baseUrl, path2, query) {
-    const u = new URL(baseUrl + (path2.startsWith("/") ? path2 : `/${path2}`));
+  url(baseUrl, path5, query) {
+    const u = new URL(baseUrl + (path5.startsWith("/") ? path5 : `/${path5}`));
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0) u.searchParams.set(k, String(v));
@@ -374,10 +790,10 @@ var Http = class {
     if (hasBody) h["Content-Type"] = "application/json";
     return h;
   }
-  async request(method, path2, init = {}) {
+  async request(method, path5, init = {}) {
     const base = await this.base();
     const hasBody = init.body !== void 0;
-    const url = this.url(base.baseUrl, path2, init.query);
+    const url = this.url(base.baseUrl, path5, init.query);
     const extra = { ...base.headers, ...init.headers };
     const f = base.fetch ?? this.fetchImpl;
     const send = async (force) => this.fetchWithTimeout(
@@ -390,7 +806,7 @@ var Http = class {
       },
       init.signal,
       method,
-      path2
+      path5
     );
     let res = await send(false);
     if (res.status === 401 && base.getToken) res = await send(true);
@@ -401,13 +817,13 @@ var Http = class {
     try {
       return JSON.parse(text);
     } catch (e) {
-      throw new MindwireError(`mindwire: ${method} ${path2} returned a non-JSON body`, { cause: e });
+      throw new MindwireError(`mindwire: ${method} ${path5} returned a non-JSON body`, { cause: e });
     }
   }
   /** Open a streaming response (SSE). Caller owns the body. */
-  async open(method, path2, init = {}) {
+  async open(method, path5, init = {}) {
     const base = await this.base();
-    const url = this.url(base.baseUrl, path2, init.query);
+    const url = this.url(base.baseUrl, path5, init.query);
     const extra = { Accept: "text/event-stream", ...base.headers, ...init.headers };
     const f = base.fetch ?? this.fetchImpl;
     const send = async (force) => this.fetchOnce(
@@ -420,13 +836,13 @@ var Http = class {
         ...init.signal ? { signal: init.signal } : {}
       },
       method,
-      path2
+      path5
     );
     let res = await send(false);
     if (res.status === 401 && base.getToken) res = await send(true);
     if (!res.ok) throw await this.toApiError(method, res);
     if (!res.body)
-      throw new MindwireError(`mindwire: ${method} ${path2} returned no response body to stream`);
+      throw new MindwireError(`mindwire: ${method} ${path5} returned no response body to stream`);
     return res;
   }
   async toApiError(method, res) {
@@ -676,12 +1092,12 @@ var ProjectSyncError = class extends MindwireError {
 };
 var active = (o) => ["queued", "exporting", "preparing", "applying"].includes(o.status);
 var prefix = "/workspace/sync";
-function delay2(ms, signal) {
+function delay4(ms, signal) {
   signal?.throwIfAborted();
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const done = () => {
       signal?.removeEventListener("abort", abort);
-      resolve();
+      resolve3();
     };
     const timer = setTimeout(done, ms);
     const abort = () => {
@@ -743,7 +1159,7 @@ var ProjectSyncApi = class {
       const o = await this.get(id, { signal: options.signal });
       options.onUpdate?.(o);
       if (!active(o)) return o;
-      await delay2(500, options.signal);
+      await delay4(500, options.signal);
     }
   }
   /** Repeating this relay skips acknowledged checkpoints and verified chunks.
@@ -919,8 +1335,8 @@ var WorkspaceApi = class {
     return this.mw.http.request("GET", "/workspace", { query: options });
   }
   /** Read the saved icon, or preview a candidate relative path within the project. Requires projectIconsVersion >= 1. */
-  projectIcon(projectId, path2) {
-    return this.mw.http.request("GET", `/workspace/projects/${encodeURIComponent(projectId)}/icon`, { query: { path: path2 } });
+  projectIcon(projectId, path5) {
+    return this.mw.http.request("GET", `/workspace/projects/${encodeURIComponent(projectId)}/icon`, { query: { path: path5 } });
   }
   /** Start an operation owned by the daemon. The same ID/payload returns the existing operation. */
   createProject(request) {
@@ -1117,17 +1533,17 @@ var ExecutionApi = class {
   resources() {
     return this.client.http.request("GET", "/workspace/resources");
   }
-  files(path2 = "", query) {
-    return this.client.http.request("GET", "/workspace/files", { query: { path: path2, query } });
+  files(path5 = "", query) {
+    return this.client.http.request("GET", "/workspace/files", { query: { path: path5, query } });
   }
-  read(path2) {
-    return this.client.http.request("GET", "/workspace/file", { query: { path: path2 } });
+  read(path5) {
+    return this.client.http.request("GET", "/workspace/file", { query: { path: path5 } });
   }
-  write(path2, content) {
-    return this.client.http.request("PUT", "/workspace/file", { body: { path: path2, content } });
+  write(path5, content) {
+    return this.client.http.request("PUT", "/workspace/file", { body: { path: path5, content } });
   }
-  remove(path2) {
-    return this.client.http.request("DELETE", "/workspace/file", { query: { path: path2 } });
+  remove(path5) {
+    return this.client.http.request("DELETE", "/workspace/file", { query: { path: path5 } });
   }
   exec(command, signal) {
     return this.client.http.request("POST", "/workspace/exec", { body: command, signal });
@@ -1201,7 +1617,7 @@ async function spawnDaemon(opts) {
       "MindWire embedded mode needs a server runtime (Node/Bun/Deno). In the browser or an edge runtime, pass { baseUrl } to connect to a running daemon."
     );
   }
-  const { spawn: spawn2 } = await import('child_process');
+  const { spawn: spawn3 } = await import('child_process');
   const net = await import('net');
   const proc = serverRuntime().process;
   const { randomBytes } = await import('crypto');
@@ -1210,7 +1626,7 @@ async function spawnDaemon(opts) {
   const port = await freePort(net);
   const baseUrl = `http://127.0.0.1:${port}`;
   const token = randomBytes(32).toString("hex");
-  const child = spawn2(bin, [], {
+  const child = spawn3(bin, [], {
     env: {
       ...proc.env,
       ADDR: `127.0.0.1:${port}`,
@@ -1239,8 +1655,8 @@ async function spawnDaemon(opts) {
   return { baseUrl, token, stop };
 }
 async function resolveBinary(explicit) {
-  const fs3 = await import('fs');
-  const path2 = await import('path');
+  const fs4 = await import('fs');
+  const path5 = await import('path');
   const proc = serverRuntime().process;
   const ext = proc.platform === "win32" ? ".exe" : "";
   const candidates = [];
@@ -1248,14 +1664,14 @@ async function resolveBinary(explicit) {
   if (proc.env?.MINDWIRE_DAEMON) candidates.push(proc.env.MINDWIRE_DAEMON);
   try {
     const url = await import('url');
-    const here = path2.dirname(url.fileURLToPath(import.meta.url));
+    const here = path5.dirname(url.fileURLToPath(import.meta.url));
     const named = `mindwired-${proc.platform}-${proc.arch}${ext}`;
-    candidates.push(path2.join(here, "bin", named), path2.join(here, "..", "bin", named));
+    candidates.push(path5.join(here, "bin", named), path5.join(here, "..", "bin", named));
   } catch {
   }
   for (const c of candidates) {
     try {
-      if (fs3.existsSync(c)) return { bin: c, found: true, checked: candidates };
+      if (fs4.existsSync(c)) return { bin: c, found: true, checked: candidates };
     } catch {
     }
   }
@@ -1278,13 +1694,13 @@ function daemonStartError(resolved, cause) {
   return `Couldn't start the mindwire daemon (${resolved.bin}): ${cause.message}. Set MINDWIRE_DAEMON to the binary path, or pass { baseUrl } to use a running daemon.`;
 }
 function freePort(net) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const srv = net.createServer();
     srv.on("error", reject);
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
       const port = addr && typeof addr === "object" ? addr.port : 0;
-      srv.close(() => resolve(port));
+      srv.close(() => resolve3(port));
     });
   });
 }
@@ -1688,8 +2104,8 @@ var Mindwire = class _Mindwire {
    * agent type. Frames are live snapshots (no replay); an empty `samples` array is a valid keep-alive.
    */
   async *processes(opts = {}) {
-    const path2 = "/processes/stream" + (opts.agent ? `?agent=${encodeURIComponent(opts.agent)}` : "");
-    const res = await this.http.open("GET", path2, {
+    const path5 = "/processes/stream" + (opts.agent ? `?agent=${encodeURIComponent(opts.agent)}` : "");
+    const res = await this.http.open("GET", path5, {
       ...opts.signal ? { signal: opts.signal } : {}
     });
     yield* readSSE(res.body, opts.signal);
@@ -1979,97 +2395,14 @@ var NotifyApi = class {
     await this.mw.http.request("DELETE", `/notify/rules/${encodeURIComponent(id)}`);
   }
 };
-async function acquireProcessLock(file, options = {}) {
-  const owner = await currentProcessIdentity();
-  const queue = file + ".queue", id = randomUUID() + ".json", claimPath = queue + "/" + id;
-  await fs.mkdir(queue, { recursive: true, mode: 448 });
-  let lock;
-  const release = async () => {
-    try {
-      if (lock) {
-        const held = lock;
-        lock = void 0;
-        const owned = await held.stat();
-        await held.close();
-        const current = await fs.stat(file).catch(() => void 0);
-        if (current?.ino === owned.ino && current.dev === owned.dev) await fs.rm(file, { force: true });
-      }
-    } finally {
-      await fs.rm(claimPath, { force: true });
-    }
-  };
-  const publish = async (claim) => {
-    const temporary = claimPath + ".tmp";
-    try {
-      await fs.writeFile(temporary, JSON.stringify(claim), { mode: 384 });
-      await fs.rename(temporary, claimPath);
-    } finally {
-      await fs.rm(temporary, { force: true });
-    }
-  };
-  const claims = async () => {
-    const entries = [];
-    for (const candidate of await fs.readdir(queue)) {
-      if (!candidate.endsWith(".json")) continue;
-      const content = await fs.readFile(queue + "/" + candidate, "utf8").catch((error) => {
-        if (error.code === "ENOENT") return void 0;
-        throw error;
-      });
-      if (content === void 0) continue;
-      const claim = JSON.parse(content);
-      if (!claim.owner || claim.ticket !== null && (!Number.isSafeInteger(claim.ticket) || claim.ticket < 1)) {
-        throw new Error("Invalid Mindwire lock ticket.");
-      }
-      if (await processStateAlive(claim.owner)) entries.push({ id: candidate, claim });
-      else await fs.rm(queue + "/" + candidate, { force: true });
-    }
-    return entries;
-  };
-  try {
-    options.signal?.throwIfAborted();
-    await publish({ owner, ticket: null });
-    const ticket = Math.max(0, ...(await claims()).map((entry) => entry.claim.ticket ?? 0)) + 1;
-    if (!Number.isSafeInteger(ticket)) throw new Error("Mindwire's connection queue is full. Retry shortly.");
-    await publish({ owner, ticket });
-    const deadline = Date.now() + 3e4;
-    while (Date.now() < deadline) {
-      options.signal?.throwIfAborted();
-      if (await options.onWait?.()) {
-        await release();
-        return void 0;
-      }
-      const ahead = (await claims()).some((entry) => entry.id !== id && (entry.claim.ticket === null || entry.claim.ticket < ticket || entry.claim.ticket === ticket && entry.id < id));
-      if (!ahead) {
-        try {
-          lock = await fs.open(file, "wx", 384);
-          await lock.writeFile(JSON.stringify(owner));
-          return { close: release };
-        } catch (error) {
-          if (error.code !== "EEXIST") throw error;
-          const holder = await readProcessState(file);
-          const age = Date.now() - (await fs.stat(file).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
-          if (age > 5e3 && !await processStateAlive(holder)) {
-            await fs.rm(file, { force: true });
-            continue;
-          }
-        }
-      }
-      await setTimeout$1(250, void 0, { signal: options.signal });
-    }
-    throw new Error("Another Mindwire operation is in progress. Try again shortly.");
-  } catch (error) {
-    await release();
-    throw error;
-  }
-}
 
 // src/computer/lifecycle.ts
-var CONTROLLER_PROTOCOL = 2;
-var defaultStateDirectory = () => path.join(homedir(), ".mindwire", "computer");
+var CONTROLLER_PROTOCOL = 3;
+var defaultStateDirectory = () => path4.join(homedir(), ".mindwire", "computer");
 var defaultComputerConfig = () => ({ directory: homedir(), bind: "0.0.0.0", sshPort: 8791, websocketPort: 8792, relay: { kind: "cloudflare" } });
 async function readJSON(file) {
   try {
-    return JSON.parse(await fs.readFile(file, "utf8"));
+    return JSON.parse(await fs2.readFile(file, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -2078,18 +2411,18 @@ async function readJSON(file) {
 async function writeJSON(file, value) {
   const temp = `${file}.${randomUUID()}.tmp`;
   try {
-    await fs.writeFile(temp, JSON.stringify(value) + "\n", { mode: 384 });
-    await fs.rename(temp, file);
+    await fs2.writeFile(temp, JSON.stringify(value) + "\n", { mode: 384 });
+    await fs2.rename(temp, file);
   } finally {
-    await fs.rm(temp, { force: true });
+    await fs2.rm(temp, { force: true });
   }
 }
 async function computerClient(directory) {
-  const runtime = await readJSON(path.join(directory, "computer-runtime.json"));
+  const runtime = await readJSON(path4.join(directory, "computer-runtime.json"));
   if (!runtime) throw new Error("Mindwire is not running. Run mindwire connect on the computer.");
   const url = new URL(`http://${runtime.apiAddress}`);
   if (!["127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password) throw new Error("Invalid local Mindwire address.");
-  const token = (await fs.readFile(path.join(directory, "daemon.token"), "utf8")).trim();
+  const token = (await fs2.readFile(path4.join(directory, "daemon.token"), "utf8")).trim();
   const client = new Mindwire({ target: remote(url.origin, { token }), requestTimeoutMs: 3e3 });
   const info = await client.computer.info();
   if (info.computerId !== runtime.computerId || info.pid !== runtime.pid) throw new Error("The local Mindwire process changed. Retry the command.");
@@ -2107,20 +2440,21 @@ function directRoutes(config, port) {
 async function ensureComputer(directory, cliPath, patch = {}, onProgress, options = {}) {
   const resume = options.resume !== false;
   options.signal?.throwIfAborted();
-  await fs.mkdir(directory, { recursive: true, mode: 448 });
-  const stoppedPath = path.join(directory, "computer-stopped.json");
-  if (resume) await fs.rm(stoppedPath, { force: true });
+  await fs2.mkdir(directory, { recursive: true, mode: 448 });
+  const stoppedPath = path4.join(directory, "computer-stopped.json");
+  if (resume) await fs2.rm(stoppedPath, { force: true });
   else if ((await readJSON(stoppedPath))?.stopped) throw new Error("Mindwire was stopped by its owner.");
   let current;
   try {
     current = await computerClient(directory);
   } catch {
   }
-  const configPath = path.join(directory, "computer-config.json");
+  const configPath = path4.join(directory, "computer-config.json");
   const previous = await readJSON(configPath);
   const config = { ...defaultComputerConfig(), ...previous, ...patch };
+  validateRelayOptions(config.relay);
   const requestedAt = resume ? Date.now() : 0;
-  if (resume) await writeJSON(path.join(directory, "computer-check.json"), { requestedAt });
+  if (resume) await writeJSON(path4.join(directory, "computer-check.json"), { requestedAt });
   const compatible = (controller) => (controller?.protocol ?? 0) >= CONTROLLER_PROTOCOL && versionAtLeast(controller?.cliVersion, SDK_VERSION);
   let launchedPID;
   let launchFailure;
@@ -2130,14 +2464,21 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
     const deadline = Date.now() + (options.timeoutMs ?? 12e4);
     while (Date.now() < deadline) {
       options.signal?.throwIfAborted();
-      const controller = await readJSON(path.join(directory, "computer-controller.json"));
+      const controller = await readJSON(path4.join(directory, "computer-controller.json"));
       lastState = controller;
       if (launchFailure) throw launchFailure;
       if (launchedPID && controller?.pid !== launchedPID) {
         await setTimeout$1(250, void 0, { signal: options.signal });
         continue;
       }
+      if (options.waitForRoutes === false && compatible(controller) && await processStateAlive(controller)) {
+        try {
+          return await computerClient(directory);
+        } catch {
+        }
+      }
       if (controller?.error && !controller.recovering) throw new Error(controller.error);
+      if (controller?.error && providerNeedsAction(controller.errorCode) && (controller.checkedAt ?? 0) >= requestedAt) throw new Error(controller.error);
       if (controller?.ready && compatible(controller) && (controller.checkedAt ?? 0) >= requestedAt && await processStateAlive(controller)) return computerClient(directory);
       if (controller?.phase && controller.phase !== phase) {
         phase = controller.phase;
@@ -2150,17 +2491,27 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
     throw new Error(`Mindwire's connection is not ready. ${lastStep}${recovering ? " Background recovery continues." : ""} Run mindwire reconnect to retry, or mindwire status for details.`);
   };
   if (current) {
-    if (Object.keys(patch).some((key) => JSON.stringify(config[key]) !== JSON.stringify(previous?.[key]))) {
-      throw new Error("Mindwire is running with different connection settings. Run mindwire stop when idle, then retry with the new settings.");
+    const changed = Object.keys(patch).filter((key) => JSON.stringify(config[key]) !== JSON.stringify(previous?.[key]));
+    if (changed.length) {
+      if (changed.some((key) => !["relay", "host"].includes(key))) {
+        throw new Error("Changing the service's directory or listening ports requires mindwire stop when idle. Connection providers can be changed live with mindwire connection.");
+      }
+      const controller2 = await readJSON(path4.join(directory, "computer-controller.json"));
+      if (!compatible(controller2) || !await processStateAlive(controller2)) {
+        await ensureComputer(directory, cliPath, {}, onProgress, { ...options, waitForRoutes: false });
+      }
+      const { changeComputerConnection } = await import('./connection-change-IBNL42BL.js');
+      await changeComputerConnection(directory, Object.fromEntries(changed.map((key) => [key, patch[key]])), { signal: options.signal, onProgress });
+      return computerClient(directory);
     }
-    const controller = await readJSON(path.join(directory, "computer-controller.json"));
+    const controller = await readJSON(path4.join(directory, "computer-controller.json"));
     if (compatible(controller) && await processStateAlive(controller)) return waitUntilReady();
   }
-  const lockPath = path.join(directory, "launch.lock");
+  const lockPath = path4.join(directory, "launch.lock");
   const lock = await acquireProcessLock(lockPath, {
     signal: options.signal,
     onWait: async () => {
-      const controller = await readJSON(path.join(directory, "computer-controller.json"));
+      const controller = await readJSON(path4.join(directory, "computer-controller.json"));
       if (compatible(controller) && await processStateAlive(controller)) {
         const saved = await readJSON(configPath);
         if (Object.keys(patch).some((key) => JSON.stringify(patch[key]) !== JSON.stringify(saved?.[key]))) {
@@ -2184,13 +2535,13 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
       if (Object.keys(patch).some((key) => JSON.stringify(patch[key]) !== JSON.stringify(saved?.[key]))) {
         throw new Error("Another start used different connection settings. Stop Mindwire when idle before changing them.");
       }
-      const controller2 = await readJSON(path.join(directory, "computer-controller.json"));
+      const controller2 = await readJSON(path4.join(directory, "computer-controller.json"));
       if (compatible(controller2) && await processStateAlive(controller2)) return waitUntilReady();
     }
-    let controller = await readJSON(path.join(directory, "computer-controller.json"));
+    let controller = await readJSON(path4.join(directory, "computer-controller.json"));
     if (existing && controller && !compatible(controller) && await processStateAlive(controller)) {
       onProgress?.("Refreshing the background connection service\u2026");
-      const { handoffController } = await import('./controller-handoff-3LAYBJUL.js');
+      const { handoffController } = await import('./controller-handoff-RUUHODNC.js');
       await handoffController(directory, controller, config, await existing.computer.info());
       controller = void 0;
     }
@@ -2198,20 +2549,20 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
       if (controller?.error && !controller.recovering) throw new Error(controller.error);
     } else {
       await writeJSON(configPath, config);
-      const log = await fs.open(path.join(directory, "computer.log"), "a", 384);
+      const log = await fs2.open(path4.join(directory, "computer.log"), "a", 384);
       try {
         const child = spawn(process.execPath, [cliPath, "_serve", "--state-dir", directory], {
           detached: true,
           stdio: ["ignore", log.fd, log.fd],
           windowsHide: true
         });
-        await new Promise((resolve, reject) => {
-          child.once("spawn", resolve);
+        await new Promise((resolve3, reject) => {
+          child.once("spawn", resolve3);
           child.once("error", reject);
         });
         launchedPID = child.pid;
         child.on("exit", () => {
-          launchFailure = new Error(`The computer controller stopped. Inspect ${path.join(directory, "computer.log")}.`);
+          launchFailure = new Error(`The computer controller stopped. Inspect ${path4.join(directory, "computer.log")}.`);
         });
         child.unref();
       } finally {
@@ -2224,20 +2575,20 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   }
 }
 async function superviseComputer(directory) {
-  const controller = await import('./controller-AGT6MCJG.js');
+  const controller = await import('./controller-2SJLZMJZ.js');
   await controller.superviseComputer(directory);
 }
 async function stopComputer(directory, force = false) {
   const client = await computerClient(directory);
-  const controller = await readJSON(path.join(directory, "computer-controller.json"));
+  const controller = await readJSON(path4.join(directory, "computer-controller.json"));
   if (!await processStateAlive(controller)) throw new Error("The Mindwire controller is not running.");
   const lease = force ? void 0 : await client.service.acquireUpdate();
   try {
-    await writeJSON(path.join(directory, "computer-stopped.json"), { stopped: true });
+    await writeJSON(path4.join(directory, "computer-stopped.json"), { stopped: true });
     if (!await processStateAlive(controller)) throw new Error("The Mindwire controller changed. Retry the command.");
     process.kill(controller.pid, "SIGTERM");
   } catch (error) {
-    await fs.rm(path.join(directory, "computer-stopped.json"), { force: true });
+    await fs2.rm(path4.join(directory, "computer-stopped.json"), { force: true });
     if (lease) await client.service.releaseUpdate(lease.id);
     throw error;
   }
@@ -2248,6 +2599,6 @@ async function stopComputer(directory, force = false) {
   throw new Error("Mindwire is still stopping. Check computer.log.");
 }
 
-export { CONTROLLER_PROTOCOL, SDK_VERSION, acquireProcessLock, adoptProcess, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, ownChild, processIdentity, processStateAlive, readJSON, stopComputer, superviseComputer, writeJSON };
-//# sourceMappingURL=chunk-3QFDSYKC.js.map
-//# sourceMappingURL=chunk-3QFDSYKC.js.map
+export { CONTROLLER_PROTOCOL, ProviderConnectionError, RelayOutput, SDK_VERSION, acquireProcessLock, adoptProcess, adoptRelay, cloudflareCommand, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultComputerConfig, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, hasCertificateError, ownChild, processIdentity, processStateAlive, providerFailure, providerNeedsAction, readJSON, startRelay, stopComputer, superviseComputer, websocketURL, writeJSON };
+//# sourceMappingURL=chunk-RTGZDLSG.js.map
+//# sourceMappingURL=chunk-RTGZDLSG.js.map