mindwire 0.1.30 → 0.1.33

package/dist/{controller-DIJKMWWU.js → controller-QBC6L7AT.js}

@@ -1,11 +1,11 @@
 import { binaryCacheDirectory, cachedExecutable, verifyReleaseBytes, cacheExecutable, executableChecksum } from './chunk-3FR7BFAW.js';
-import { readJSON, processStateAlive, currentProcessIdentity, ensureDaemonBinary, SDK_VERSION, computerClient, processIdentity, adoptProcess, writeJSON, directRoutes, CONTROLLER_PROTOCOL, ownChild } from './chunk-RN7ERVJ2.js';
+import { readJSON, processStateAlive, currentProcessIdentity, ensureDaemonBinary, SDK_VERSION, computerClient, processIdentity, adoptProcess, writeJSON, directRoutes, CONTROLLER_PROTOCOL, ownChild } from './chunk-H2I3VRBS.js';
 import './chunk-T6TD76UA.js';
 import { execFile, execFileSync, spawn } from 'child_process';
-import { randomBytes } from 'crypto';
+import { randomBytes, randomUUID } from 'crypto';
 import * as fs from 'fs/promises';
-import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
-import * as path2 from 'path';
+import { open, rm, readFile, mkdtemp, writeFile } from 'fs/promises';
+import * as path3 from 'path';
 import { setTimeout as setTimeout$1 } from 'timers/promises';
 import { tmpdir } from 'os';
 import { promisify } from 'util';
@@ -23,7 +23,7 @@ async function ensureCloudflareBinary(options = {}) {
     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 = path2.join(
+  const bin = path3.join(
     options.cacheDir ?? await binaryCacheDirectory(),
     "cloudflared",
     CLOUDFLARED_VERSION,
@@ -50,9 +50,9 @@ async function ensureCloudflareBinary(options = {}) {
   await verifyReleaseBytes(archive, checksum, asset);
   let executable = archive;
   if (platform === "darwin") {
-    const temporary = await mkdtemp(path2.join(tmpdir(), "mindwire-cloudflared-"));
+    const temporary = await mkdtemp(path3.join(tmpdir(), "mindwire-cloudflared-"));
     try {
-      const archivePath = path2.join(temporary, asset);
+      const archivePath = path3.join(temporary, asset);
       await writeFile(archivePath, archive, { mode: 384 });
       const result = await execute(
         "/usr/bin/tar",
@@ -75,8 +75,70 @@ async function cloudflareCommand(options) {
     return ensureCloudflareBinary(options);
   }
 }
+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 = path3.join(directory, `.relay-output-${randomUUID()}.log`);
+    return new _RelayOutput(file, await open(file, "ax+", 384));
+  }
+  static async adopt(directory, file) {
+    if (path3.dirname(file) !== path3.resolve(directory) || !/^\.relay-output-[a-f0-9-]{36}\.log$/.test(path3.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/relay.ts
+async function adoptRelay(owner, route, directory, outputFile) {
+  const output = outputFile ? await RelayOutput.adopt(directory, outputFile) : void 0;
+  return { route, owner, outputFile: output?.file, async close() {
+    await owner.close();
+    await output?.close();
+  } };
+}
 function websocketURL(value) {
   const url = new URL(value);
   if (url.protocol === "https:") url.protocol = "wss:";
@@ -118,84 +180,78 @@ async function startRelay(options, port, runtime = {}) {
     }
   }
   runtime.signal?.throwIfAborted();
-  const child = spawn(command, args, { env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
-  let buffer = "";
+  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 {
-    const address = new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        cleanup();
-        reject(new Error(`${command} did not establish its tunnel. Check its account and tunnel configuration.`));
-      }, 45e3);
-      const cleanup = () => {
-        clearTimeout(timer);
-        child.off("error", fail);
-        child.off("exit", exited);
-        runtime.signal?.removeEventListener("abort", aborted);
-      };
-      const fail = (error) => {
-        cleanup();
-        reject(new Error(`Could not run ${command}. Install it on the computer first.`, { cause: error }));
-      };
-      const exited = () => {
-        cleanup();
-        reject(new Error(`${command} exited before the tunnel connected. Check its account configuration.`));
-      };
-      const aborted = () => {
-        cleanup();
-        child.kill();
-        reject(runtime.signal?.reason ?? new Error("Tunnel startup cancelled."));
-      };
-      let cloudflareAddress = options.url;
-      let cloudflareConnected = false;
-      const receive = (chunk) => {
-        const received = buffer + chunk.toString();
-        buffer = received.slice(-16384);
-        let found;
-        if (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 (event.msg === "started tunnel" && event.url?.startsWith("https://")) found = event.url;
-            } catch {
-            }
+    await new Promise((resolve3, reject) => {
+      child.once("spawn", resolve3);
+      child.once("error", reject);
+    });
+    owner = await ownChild(child);
+    await runtime.onSpawn?.(owner, output.file);
+    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 });
+      if (!owner.alive()) throw new Error(`${options.kind} exited before the tunnel connected. Check its account configuration.`);
+      const received = buffer + (await output.read()).toString();
+      buffer = received.slice(-16384);
+      let found;
+      if (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 (event.msg === "started tunnel" && event.url?.startsWith("https://")) found = event.url;
+          } catch {
           }
         }
-        if (found) {
-          cleanup();
-          resolve2(websocketURL(found));
-        }
-      };
-      child.once("error", fail);
-      child.once("exit", exited);
-      child.stdout.on("data", receive);
-      child.stderr.on("data", receive);
-      runtime.signal?.addEventListener("abort", aborted, { once: true });
-      if (runtime.signal?.aborted) aborted();
-    });
-    void address.catch(() => {
-    });
-    const owner = await ownChild(child);
-    await runtime.onSpawn?.(owner);
-    const url = await address;
-    runtime.signal?.throwIfAborted();
-    child.stdout.removeAllListeners("data");
-    child.stderr.removeAllListeners("data");
-    child.stdout.resume();
-    child.stderr.resume();
-    child.on("error", () => {
-    });
-    return { route: { kind: "websocket", url }, process: child, owner, close: () => owner.close() };
+      }
+      if (found) {
+        const route = { kind: "websocket", url: websocketURL(found) };
+        output.discard();
+        const provider = owner;
+        return {
+          route,
+          process: child,
+          owner,
+          outputFile: output.file,
+          async close() {
+            await provider.close();
+            await output.close();
+          }
+        };
+      }
+      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) {
-    child.on("error", () => {
-    });
-    if (child.pid) await (await ownChild(child)).close();
+    if (owner) await owner.close();
+    else if (child.pid) await (await ownChild(child)).close();
+    await output.close();
     throw error;
   }
 }
+var RelayCheckError = class extends Error {
+  constructor(code, message, cause) {
+    super(message, cause ? { cause } : void 0);
+    this.code = code;
+    this.name = "RelayCheckError";
+  }
+  code;
+};
+function relayNeedsRestart(error, failures, failedForMs) {
+  return failures >= 2 && failedForMs >= 9e4 && !(error instanceof RelayCheckError && error.code === "dns");
+}
 var relayLookup = (hostname, options, callback) => {
   lookup(hostname, options, (error, address, family) => {
     if (error?.code !== "ENOTFOUND" || !/^[a-z0-9-]+\.trycloudflare\.com$/i.test(hostname)) {
@@ -220,8 +276,8 @@ var relayLookup = (hostname, options, callback) => {
 async function checkRelay(route, options = {}) {
   options.signal?.throwIfAborted();
   if (route.kind !== "websocket") throw new Error("Expected an internet tunnel address.");
-  await new Promise((resolve2, reject) => {
-    const socket = new WebSocket(route.url, { maxPayload: 4096, perMessageDeflate: false, followRedirects: false, lookup: relayLookup });
+  await new Promise((resolve3, reject) => {
+    const socket = new WebSocket(route.url, { maxPayload: 4096, perMessageDeflate: false, followRedirects: false, lookup: options.lookup ?? relayLookup });
     let finished = false, banner = "";
     const finish = (error) => {
       if (finished) return;
@@ -230,27 +286,33 @@ async function checkRelay(route, options = {}) {
       options.signal?.removeEventListener("abort", aborted);
       socket.terminate();
       if (error) reject(error);
-      else resolve2();
+      else resolve3();
     };
     const aborted = () => finish(options.signal?.reason ?? new Error("Connection check cancelled."));
-    const timer = setTimeout(() => finish(new Error("The internet tunnel isn't responding. Reconnecting\u2026")), options.timeoutMs ?? 8e3);
-    socket.on("error", (error) => finish(new Error(
-      error.code === "ENOTFOUND" ? "The internet address isn't available. Checking the tunnel\u2026" : /(?:[Uu]nexpected server response|[Ee]xpected 101)/.test(error.message) ? "The internet tunnel isn't reaching Mindwire. Reconnecting\u2026" : "The internet tunnel couldn't connect. Retrying\u2026",
-      { cause: error }
-    )));
-    socket.on("close", () => finish(new Error("The internet tunnel closed before reaching Mindwire. Retrying\u2026")));
+    const timer = setTimeout(() => finish(new RelayCheckError("timeout", "The internet tunnel isn't responding. Retrying\u2026")), options.timeoutMs ?? 8e3);
+    socket.on("error", (error) => {
+      if (["ENOTFOUND", "EAI_AGAIN"].includes(error.code ?? "")) {
+        const provider = new URL(route.url).hostname.endsWith(".trycloudflare.com") ? "Cloudflare's" : "the tunnel's";
+        finish(new RelayCheckError("dns", `Waiting for ${provider} internet address (DNS)\u2026`, error));
+      } else if (/(?:[Uu]nexpected server response|[Ee]xpected 101)/.test(error.message)) {
+        finish(new RelayCheckError("proxy", "The internet tunnel isn't reaching Mindwire. Retrying\u2026", error));
+      } else {
+        finish(new RelayCheckError("connection", "The internet tunnel couldn't connect. Retrying\u2026", error));
+      }
+    });
+    socket.on("close", () => finish(new RelayCheckError("connection", "The internet tunnel closed before reaching Mindwire. Retrying\u2026")));
     socket.on("message", (data, binary) => {
       if (!binary) {
-        finish(new Error("The internet tunnel returned an invalid SSH response."));
+        finish(new RelayCheckError("response", "The internet tunnel returned an invalid SSH response."));
         return;
       }
       banner += data.toString();
       if (banner.length > 1024) {
-        finish(new Error("The internet tunnel returned an invalid SSH response."));
+        finish(new RelayCheckError("response", "The internet tunnel returned an invalid SSH response."));
         return;
       }
       if (banner.includes("\n")) {
-        finish(banner.split("\n")[0]?.trim() === "SSH-2.0-Mindwire" ? void 0 : new Error("The internet tunnel isn't connected to the Mindwire SSH service."));
+        finish(banner.split("\n")[0]?.trim() === "SSH-2.0-Mindwire" ? void 0 : new RelayCheckError("response", "The internet tunnel isn't connected to the Mindwire SSH service."));
       }
     });
     options.signal?.addEventListener("abort", aborted, { once: true });
@@ -260,7 +322,7 @@ async function checkRelay(route, options = {}) {
 async function relayProviderReachable(options, signal) {
   if (options.kind !== "cloudflare" && options.kind !== "ngrok") return false;
   signal?.throwIfAborted();
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const url = options.kind === "cloudflare" ? "https://api.trycloudflare.com/" : "https://api.ngrok.com/";
     let finished = false;
     const done = (reachable) => {
@@ -268,7 +330,7 @@ async function relayProviderReachable(options, signal) {
       finished = true;
       clearTimeout(timer);
       probe.destroy();
-      resolve2(reachable);
+      resolve3(reachable);
     };
     const probe = request(url, { method: "HEAD", signal }, (response) => {
       response.destroy();
@@ -285,11 +347,11 @@ function recoveryDelay(failures) {
   return Math.min(6e4, 1e3 * 2 ** Math.min(6, Math.max(0, failures - 1)));
 }
 async function superviseComputer(directory) {
-  if ((await readJSON(path2.join(directory, "computer-stopped.json")))?.stopped) return;
-  let config = await readJSON(path2.join(directory, "computer-config.json"));
+  if ((await readJSON(path3.join(directory, "computer-stopped.json")))?.stopped) return;
+  let config = await readJSON(path3.join(directory, "computer-config.json"));
   if (!config) throw new Error("Computer configuration is missing.");
-  const controllerPath = path2.join(directory, "computer-controller.json");
-  const relayPath = path2.join(directory, "computer-relay.json");
+  const controllerPath = path3.join(directory, "computer-controller.json");
+  const relayPath = path3.join(directory, "computer-relay.json");
   const previous = await readJSON(controllerPath);
   if (await processStateAlive(previous)) throw new Error("The computer already has a service controller.");
   const owner = await currentProcessIdentity();
@@ -309,30 +371,30 @@ async function superviseComputer(directory) {
   process.on("SIGINT", stop);
   let token;
   try {
-    token = (await fs.readFile(path2.join(directory, "daemon.token"), "utf8")).trim();
+    token = (await fs.readFile(path3.join(directory, "daemon.token"), "utf8")).trim();
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
     token = randomBytes(32).toString("hex");
-    await fs.writeFile(path2.join(directory, "daemon.token"), token, { mode: 384, flag: "wx" });
+    await fs.writeFile(path3.join(directory, "daemon.token"), token, { mode: 384, flag: "wx" });
   }
   const daemonEnv = { ...process.env };
   if (process.platform === "win32") {
     try {
       const git = execFileSync("where.exe", ["git"], { encoding: "utf8", timeout: 3e3, windowsHide: true }).split(/\r?\n/)[0];
       if (git) {
-        const shellDirectory = path2.resolve(path2.dirname(git), "..", "bin");
-        await fs.access(path2.join(shellDirectory, "bash.exe"));
+        const shellDirectory = path3.resolve(path3.dirname(git), "..", "bin");
+        await fs.access(path3.join(shellDirectory, "bash.exe"));
         const pathKey = Object.keys(daemonEnv).find((key) => key.toLowerCase() === "path") ?? "PATH";
-        daemonEnv[pathKey] = `${shellDirectory}${path2.delimiter}${daemonEnv[pathKey] ?? ""}`;
+        daemonEnv[pathKey] = `${shellDirectory}${path3.delimiter}${daemonEnv[pathKey] ?? ""}`;
       }
     } catch {
     }
   }
-  const oldRuntime = await readJSON(path2.join(directory, "computer-runtime.json"));
+  const oldRuntime = await readJSON(path3.join(directory, "computer-runtime.json"));
   let sshPort = config.sshPort || oldRuntime?.sshPort || 0;
   let websocketPort = config.websocketPort || oldRuntime?.websocketPort || 0;
   const launch = async (binary) => {
-    await fs.rm(path2.join(directory, "computer-runtime.json"), { force: true });
+    await fs.rm(path3.join(directory, "computer-runtime.json"), { force: true });
     const process2 = spawn(binary, ["--computer"], {
       cwd: config.directory,
       stdio: ["ignore", "inherit", "inherit"],
@@ -341,8 +403,8 @@ async function superviseComputer(directory) {
         ...daemonEnv,
         DAEMON_TOKEN: token,
         ADDR: "127.0.0.1:0",
-        STATE_PATH: path2.join(directory, "agent-state.json"),
-        WORKSPACE_DB_PATH: path2.join(directory, "workspace.db"),
+        STATE_PATH: path3.join(directory, "agent-state.json"),
+        WORKSPACE_DB_PATH: path3.join(directory, "workspace.db"),
         AGENT_CWD: config.directory,
         COMPUTER_SSH_ADDR: `${config.bind.includes(":") ? `[${config.bind}]` : config.bind}:${sshPort}`,
         COMPUTER_WS_ADDR: `127.0.0.1:${websocketPort}`,
@@ -353,8 +415,8 @@ async function superviseComputer(directory) {
     process2.on("error", (error) => {
       failure = error;
     });
-    await new Promise((resolve2, reject) => {
-      process2.once("spawn", resolve2);
+    await new Promise((resolve3, reject) => {
+      process2.once("spawn", resolve3);
       process2.once("error", reject);
     });
     child = await ownChild(process2);
@@ -381,6 +443,7 @@ async function superviseComputer(directory) {
   let routes = [], published = "";
   let client;
   let relayMessage = "Preparing your internet connection\u2026", relayError;
+  let relayErrorCode;
   let daemonError, nextDaemonAt = 0, daemonFailures = 0;
   let nextRelayAt = 0, relayFailures = 0, changingDaemon = false;
   let daemonReadyAt = Date.now(), relayReadyAt = Date.now();
@@ -409,11 +472,16 @@ async function superviseComputer(directory) {
     if (saved) {
       const owner2 = await adoptProcess(saved.owner);
       if (owner2) {
-        if (saved.route && saved.port === websocketPort && saved.options === JSON.stringify(config.relay)) {
-          relay = { route: saved.route, owner: owner2, close: () => owner2.close() };
+        if (saved.outputFile && saved.route && saved.port === websocketPort && saved.options === JSON.stringify(config.relay)) {
+          relay = await adoptRelay(owner2, saved.route, directory, saved.outputFile);
         } else {
-          await owner2.close();
+          if (!saved.outputFile) await phase("Refreshing the internet tunnel for this update\u2026");
+          const abandoned = await adoptRelay(owner2, saved.route, directory, saved.outputFile);
+          await abandoned.close();
+          await fs.rm(relayPath, { force: true });
         }
+      } else if (saved.outputFile) {
+        await (await RelayOutput.adopt(directory, saved.outputFile))?.close();
       }
     }
     let lastController = "";
@@ -443,9 +511,11 @@ async function superviseComputer(directory) {
         }
       }
       if (relay?.owner && !relay.owner.alive()) {
+        await relay.close();
         relay = void 0;
         relayReachable = false;
         relayWasReachable = false;
+        relayErrorCode = void 0;
         relayError = "The internet tunnel disconnected. Reconnecting\u2026";
         nextRelayAt = Date.now() + recoveryDelay(++relayFailures);
       }
@@ -456,6 +526,7 @@ async function superviseComputer(directory) {
         if (result.handle) {
           relay = result.handle;
           relayError = void 0;
+          relayErrorCode = void 0;
           relayReadyAt = Date.now();
           relayReachable = false;
           relayWasReachable = false;
@@ -466,7 +537,8 @@ async function superviseComputer(directory) {
             owner: relay.owner.identity,
             port: websocketPort,
             options: JSON.stringify(config.relay),
-            route: relay.route
+            route: relay.route,
+            outputFile: relay.outputFile
           });
         } else {
           relayError = result.error instanceof Error ? result.error.message : "The internet tunnel couldn't connect.";
@@ -474,18 +546,22 @@ async function superviseComputer(directory) {
         }
       }
       if (!relay && !relayTask && Date.now() >= nextRelayAt) {
+        relayError = void 0;
+        relayErrorCode = void 0;
         relayMessage = "Reconnecting your internet tunnel\u2026";
         relayTask = startRelay(config.relay, websocketPort, {
-          cacheDir: path2.join(directory, "tools"),
+          cacheDir: path3.join(directory, "tools"),
+          outputDirectory: directory,
           signal: abort.signal,
           onProgress: (message) => {
             relayMessage = message;
           },
-          onSpawn: async (owner2) => {
+          onSpawn: async (owner2, outputFile) => {
             if (owner2.identity) await writeJSON(relayPath, {
               owner: owner2.identity,
               port: websocketPort,
-              options: JSON.stringify(config.relay)
+              options: JSON.stringify(config.relay),
+              outputFile
             });
           }
         }).then((handle) => {
@@ -506,9 +582,11 @@ async function superviseComputer(directory) {
             relayHealthFailures = 0;
             relayFailedAt = 0;
             relayError = void 0;
+            relayErrorCode = void 0;
             nextCheckAt = checkedAt + 3e4;
           } else {
             relayError = result.error instanceof Error ? result.error.message : "The internet tunnel couldn't connect. Retrying\u2026";
+            relayErrorCode = result.error instanceof RelayCheckError ? result.error.code : void 0;
             relayFailedAt ||= checkedAt;
             relayHealthFailures++;
             nextCheckAt = checkedAt + Math.min(15e3, recoveryDelay(relayHealthFailures));
@@ -522,7 +600,7 @@ async function superviseComputer(directory) {
           }
         }
       }
-      const requestedCheck = await readJSON(path2.join(directory, "computer-check.json"));
+      const requestedCheck = await readJSON(path3.join(directory, "computer-check.json"));
       if (config.relay.kind === "none") checkedAt = Math.max(checkedAt, requestedCheck?.requestedAt ?? 0);
       if (relay?.route && !checkTask && (Date.now() >= nextCheckAt || (requestedCheck?.requestedAt ?? 0) > checkedAt)) {
         const checking = relay;
@@ -531,7 +609,7 @@ async function superviseComputer(directory) {
             await checkRelay(checking.route, { signal: abort.signal });
             checkResult = { relay: checking };
           } catch (error) {
-            const canRestart = !!checking.owner && relayHealthFailures >= 2 && relayFailedAt > 0 && Date.now() - relayFailedAt >= 9e4 && await relayProviderReachable(config.relay, abort.signal).catch(() => false);
+            const canRestart = !!checking.owner && relayFailedAt > 0 && relayNeedsRestart(error, relayHealthFailures, Date.now() - relayFailedAt) && await relayProviderReachable(config.relay, abort.signal).catch(() => false);
             checkResult = { relay: checking, error, canRestart };
           }
         })();
@@ -556,6 +634,7 @@ async function superviseComputer(directory) {
         checkedAt,
         phase: ready ? void 0 : daemonError ?? relayError ?? relayMessage,
         error: daemonError ?? relayError,
+        errorCode: daemonError ? void 0 : relayErrorCode,
         recovering: !ready
       };
       const serialized = JSON.stringify(state);
@@ -563,7 +642,7 @@ async function superviseComputer(directory) {
         await writeJSON(controllerPath, state);
         lastController = serialized;
       }
-      const updatePath = path2.join(directory, "computer-update.json");
+      const updatePath = path3.join(directory, "computer-update.json");
       const update = !updateTask && client && child?.alive() ? await readJSON(updatePath) : void 0;
       if (update && ["queued", "downloading", "waiting", "restarting"].includes(update.status)) {
         updateTask = (async () => {
@@ -603,7 +682,7 @@ async function superviseComputer(directory) {
             }
             binary = replacement;
             config = { ...config, daemonBin: void 0, version: update.version };
-            await writeJSON(path2.join(directory, "computer-config.json"), config);
+            await writeJSON(path3.join(directory, "computer-config.json"), config);
             await client.computer.setRoutes(routes);
             published = JSON.stringify(routes);
             await status("complete");
@@ -637,5 +716,5 @@ async function superviseComputer(directory) {
 }
 
 export { recoveryDelay, superviseComputer };
-//# sourceMappingURL=controller-DIJKMWWU.js.map
-//# sourceMappingURL=controller-DIJKMWWU.js.map
+//# sourceMappingURL=controller-QBC6L7AT.js.map
+//# sourceMappingURL=controller-QBC6L7AT.js.map