mindwire 0.1.36 → 0.1.40

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { connectionAddress, connectionInfo, connectionDescription } from './chunk-67BNDGRK.js';
-import { defaultStateDirectory, superviseComputer, computerClient, ensureComputer, readJSON, defaultComputerConfig, computerPairingURI, stopComputer, SDK_VERSION, providerFailure, writeJSON, currentProcessIdentity, processStateAlive, acquireProcessLock, websocketURL, providerNeedsAction, cloudflareCommand, computerPairingQRData, ProviderConnectionError } from './chunk-RTGZDLSG.js';
+import { enableAddressDiscovery, disableAddressDiscovery, discoveryDescription, connectionAddress, saveDiscoveryPreference, discoveryPreference, reconcileAddressDiscovery, connectionInfo, connectionDescription, updateComputer, updateProgress, activeUpdate } from './chunk-ZP7F7LP7.js';
+import { SDK_VERSION, defaultStateDirectory, computerClient, superviseComputer, ensureComputer, readJSON, defaultComputerConfig, computerPairingURI, stopComputer, processStateAlive, providerFailure, acquireProcessLock, writeJSON, currentProcessIdentity, CONTROLLER_PROTOCOL, versionAtLeast, websocketURL, providerNeedsAction, cloudflareCommand, computerPairingQRData, ProviderConnectionError } from './chunk-BJL5K6M7.js';
 import './chunk-PFYKJ6LX.js';
 import { promisify, parseArgs } from 'util';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -11,10 +11,10 @@ import { createHash, randomUUID } from 'crypto';
 import { createInterface } from 'readline/promises';
 import { setTimeout as setTimeout$1 } from 'timers/promises';
 import { execFile, spawn } from 'child_process';
-import { homedir, hostname, tmpdir } from 'os';
+import { hostname, homedir, tmpdir } from 'os';
 import * as fs from 'fs/promises';
-import { rm } from 'fs/promises';
-import { cursorTo, clearLine, createInterface as createInterface$1 } from 'readline';
+import { readFile, rm } from 'fs/promises';
+import { emitKeypressEvents, cursorTo, clearLine, createInterface as createInterface$1 } from 'readline';
 import { TunnelClient, Oblien } from 'oblien';
 import { Writable } from 'stream';
 
@@ -221,6 +221,18 @@ var execute = promisify(execFile);
 var xml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 var systemd = (value, expandEnvironment = false) => '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%").replace(/\$/g, () => expandEnvironment ? "$$" : "$") + '"';
 var windowsArg = (value) => '"' + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1") + '"';
+async function startupExecutable(executable = process.execPath, environmentPath = process.env.PATH ?? "") {
+  const homebrew = executable.match(/^(.*)\/Cellar\/([^/]+)\/[^/]+\/(.+)$/);
+  const candidates = [
+    ...homebrew ? [`${homebrew[1]}/opt/${homebrew[2]}/${homebrew[3]}`] : [],
+    ...environmentPath.split(path.delimiter).filter((part) => path.isAbsolute(part)).map((part) => path.join(part, path.basename(executable)))
+  ];
+  const target = await fs.realpath(executable);
+  for (const candidate of candidates) {
+    if (candidate !== executable && await fs.realpath(candidate).catch(() => void 0) === target) return candidate;
+  }
+  return executable;
+}
 function startupPlan(options) {
   const { directory, cliPath } = options;
   const executable = options.executable ?? process.execPath, home = options.home ?? homedir();
@@ -310,7 +322,16 @@ var run = async ([command, ...args]) => {
 async function startupStatus(directory) {
   const state = await readJSON(path.join(directory, "computer-startup.json")) ?? { enabled: false };
   const guardian = await readJSON(path.join(directory, "computer-guardian.json"));
-  return { ...state, running: state.enabled && await processStateAlive(guardian) };
+  let registered = false;
+  if (state.enabled && state.name && state.kind) {
+    const query = state.kind === "launchd" ? ["launchctl", "print", `gui/${process.getuid?.()}/${state.name}`] : state.kind === "systemd" ? ["systemctl", "--user", "is-enabled", state.name + ".service"] : ["schtasks.exe", "/Query", "/TN", state.name];
+    try {
+      await run(query);
+      registered = true;
+    } catch {
+    }
+  }
+  return { ...state, registered, running: state.enabled && registered && await processStateAlive(guardian) };
 }
 async function configureStartup(directory, cliPath, enabled, runtime = {}) {
   await fs.mkdir(directory, { recursive: true, mode: 448 });
@@ -319,7 +340,7 @@ async function configureStartup(directory, cliPath, enabled, runtime = {}) {
   if (!lock) throw new Error("Startup is already being configured. Try again shortly.");
   try {
     const user = process.platform === "win32" && !runtime.plan ? (await execute("whoami.exe", [], { timeout: 3e3, windowsHide: true })).stdout.trim() : void 0;
-    const plan = runtime.plan ?? startupPlan({ directory, cliPath, user });
+    const plan = runtime.plan ?? startupPlan({ directory, cliPath, user, executable: await startupExecutable() });
     const command = runtime.run ?? run;
     let loaded = false;
     try {
@@ -340,8 +361,28 @@ async function configureStartup(directory, cliPath, enabled, runtime = {}) {
           await fs.rm(temporary, { force: true });
         }
       }
-      if (!loaded || changed && plan.kind !== "launchd") {
-        for (const action of plan.enable) await command(action);
+      const guardianRunning = loaded && (runtime.isRunning ? await runtime.isRunning() : await processStateAlive(await readJSON(path.join(directory, "computer-guardian.json"))));
+      const reload = loaded && (runtime.repair || changed || !guardianRunning);
+      if (reload && plan.kind === "launchd") await command(plan.disable[0]);
+      if (reload && plan.kind === "task-scheduler") {
+        try {
+          await command(plan.disable[0]);
+        } catch {
+        }
+      }
+      if (!loaded || reload) {
+        for (const action of plan.enable) {
+          for (let attempt = 0; ; attempt++) {
+            try {
+              await command(action);
+              break;
+            } catch (error) {
+              if (plan.kind !== "launchd" || !action.includes("bootstrap") || error.code !== 5 || attempt >= 7) throw error;
+              await setTimeout$1(100 * (attempt + 1));
+            }
+          }
+        }
+        if (reload && plan.kind === "systemd") await command(["systemctl", "--user", "restart", plan.name + ".service"]);
       }
       await command(plan.query);
       if (runtime.verify) await runtime.verify();
@@ -372,7 +413,7 @@ async function configureStartup(directory, cliPath, enabled, runtime = {}) {
     }
     const state = { enabled, kind: plan.kind, name: plan.name, file: plan.file };
     await writeJSON(path.join(directory, "computer-startup.json"), state);
-    return { ...state, running: enabled };
+    return { ...state, registered: enabled, running: enabled };
   } finally {
     await lock.close();
   }
@@ -388,12 +429,18 @@ async function watchComputer(directory, cliPath) {
   process.on("SIGINT", stop);
   let reportedError = "";
   const guardianPath = path.join(directory, "computer-guardian.json");
+  const lock = await acquireProcessLock(path.join(directory, "guardian.lock"), { signal: abort.signal });
+  if (!lock) {
+    process.off("SIGTERM", stop);
+    process.off("SIGINT", stop);
+    return;
+  }
   try {
     await writeJSON(guardianPath, await currentProcessIdentity());
     while (!stopping) {
       const paused = await readJSON(path.join(directory, "computer-stopped.json"));
       const controller = await readJSON(path.join(directory, "computer-controller.json"));
-      if (!paused?.stopped && !await processStateAlive(controller)) {
+      if (!paused?.stopped && (!await processStateAlive(controller) || (controller?.protocol ?? 0) < CONTROLLER_PROTOCOL || !versionAtLeast(controller?.cliVersion, SDK_VERSION))) {
         try {
           await ensureComputer(directory, cliPath, {}, void 0, { resume: false, signal: abort.signal });
           reportedError = "";
@@ -413,6 +460,7 @@ async function watchComputer(directory, cliPath) {
     if ((await readJSON(guardianPath))?.pid === process.pid) await writeJSON(guardianPath, { pid: 0 });
     process.off("SIGTERM", stop);
     process.off("SIGINT", stop);
+    await lock.close();
   }
 }
 
@@ -513,174 +561,6 @@ var ConnectionProgress = class {
     this.stream.write(text + elapsed);
   }
 };
-
-// src/computer/directory-http.ts
-var DirectoryRequestError = class extends Error {
-  constructor(status, code, retryAfter = 0) {
-    super(
-      status === 0 ? "Couldn't reach the address directory securely. Check its HTTPS address and retry." : `The address directory rejected the request (${code}).`
-    );
-    this.status = status;
-    this.code = code;
-    this.retryAfter = retryAfter;
-  }
-  status;
-  code;
-  retryAfter;
-};
-async function directoryRequest(url, path5, body) {
-  let response;
-  try {
-    response = await fetch(url + path5, {
-      method: "POST",
-      redirect: "error",
-      signal: AbortSignal.timeout(1e4),
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  } catch {
-    throw new DirectoryRequestError(0, "unreachable");
-  }
-  const reader = response.body?.getReader();
-  const chunks = [];
-  let length = 0;
-  try {
-    if (reader)
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        length += value.byteLength;
-        if (length > 64 * 1024) throw new Error("The address directory returned an oversized response.");
-        chunks.push(value);
-      }
-  } finally {
-    void reader?.cancel().catch(() => {
-    });
-  }
-  let data;
-  try {
-    data = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  } catch {
-    throw new DirectoryRequestError(response.status, "invalid_response");
-  }
-  if (!response.ok) {
-    const error = data?.error;
-    const code = typeof error === "string" ? error : error?.code;
-    const retryAfter = Number(response.headers.get("Retry-After"));
-    throw new DirectoryRequestError(
-      response.status,
-      typeof code === "string" && /^[a-z_]{1,64}$/.test(code) ? code : "directory_error",
-      Number.isFinite(retryAfter) ? Math.max(0, Math.min(60, retryAfter)) : 0
-    );
-  }
-  return data;
-}
-
-// src/computer/discovery.ts
-var DIRECTORY_API_PATH = "/api/computer-directory/v1";
-var DIRECTORY_URL = `https://console.mindwire.sh${DIRECTORY_API_PATH}`;
-function directoryURL(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error("Enter the directory's HTTPS API URL.");
-  }
-  if (value.length > 2048 || /[\s\x00]/.test(value) || url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
-    throw new Error("Use an HTTPS directory URL without credentials, a query, or a fragment.");
-  }
-  if (url.pathname === "/") url.pathname = DIRECTORY_API_PATH;
-  if (url.pathname.endsWith("/") || url.pathname.includes("//") || url.pathname.includes("%")) {
-    throw new Error("Use the exact directory API URL without a trailing slash.");
-  }
-  return url.href;
-}
-async function enableAddressDiscovery(options) {
-  const lock = await acquireProcessLock(join(options.directory, "discovery-setup.lock"));
-  try {
-    let status;
-    try {
-      status = await options.computer.computer.discovery();
-    } catch (error) {
-      if (error.status === 404)
-        throw new Error("Update the Mindwire service before enabling automatic address recovery.");
-      throw error;
-    }
-    const url = directoryURL(
-      options.url ?? process.env.MINDWIRE_DIRECTORY_URL ?? status.url ?? DIRECTORY_URL
-    );
-    if (status.url && status.url !== url && (status.enabled || (status.sequence ?? 0) !== (status.publishedSequence ?? 0))) {
-      throw new Error(
-        "Disable the current directory with mindwire discovery disable and wait for its withdrawal before changing the directory URL."
-      );
-    }
-    if (!status.enabled || status.url !== url || status.error?.includes("enrollment")) {
-      options.prompt.print(`Enabling encrypted address recovery with ${new URL(url).host}\u2026`);
-      try {
-        const challenge = await directoryRequest(url, "/registrations/challenge", {
-          directoryId: status.directoryId
-        });
-        if (typeof challenge?.challenge !== "string" || challenge.challenge.length < 16 || challenge.challenge.length > 2048) {
-          throw new Error("The address directory returned an invalid enrollment challenge.");
-        }
-        const proof = await options.computer.computer.directoryEnrollment(url, challenge.challenge);
-        const enrolled = await directoryRequest(url, "/registrations", proof);
-        if (enrolled?.directoryId !== status.directoryId)
-          throw new Error("The directory acknowledged a different computer.");
-      } catch (error) {
-        if (error instanceof DirectoryRequestError) {
-          if (error.status === 404 || error.status === 501)
-            throw new Error(
-              "The address directory isn't available at this URL. Your existing connection still works; retry after the backend is deployed."
-            );
-          if (error.status === 409)
-            throw new Error(
-              "This computer's directory registration is revoked or conflicts with its saved identity. Contact the directory operator."
-            );
-          if (error.code === "account_required")
-            throw new Error(
-              "This directory still requires an account. Update its Mindwire backend to enable key-based registration, or choose another directory with --directory-url."
-            );
-          if (error.status === 401 || error.status === 403)
-            throw new Error(
-              "The directory couldn't verify this computer's key or challenge. Retry enrollment."
-            );
-          if (error.status === 429)
-            throw new Error(
-              "The directory's registration limit was reached. Retry later or use another directory."
-            );
-          if (error.status === 503)
-            throw new Error(
-              "The directory is temporarily unavailable or at capacity. Your existing connection still works."
-            );
-        }
-        throw error;
-      }
-      status = await options.computer.computer.configureDiscovery(true, url);
-    }
-    const deadline = Date.now() + 15e3;
-    while (Date.now() < deadline) {
-      status = await options.computer.computer.discovery();
-      if (status.enabled && status.sequence && status.publishedSequence === status.sequence) return status;
-      if (status.error?.includes("enrollment") || status.error?.includes("older revision"))
-        throw new Error(status.error);
-      await setTimeout$1(250);
-    }
-    throw new Error(
-      "Address recovery is configured and will retry in the background. Run mindwire discovery status to check publication."
-    );
-  } finally {
-    await lock?.close();
-  }
-}
-function discoveryDescription(status) {
-  if (!status?.enabled) return "Automatic address recovery is off. Enable it with mindwire discovery enable.";
-  if (status.error) return status.error;
-  return status.sequence && status.publishedSequence === status.sequence ? "Encrypted address recovery is on. Saved phones can find this computer when its tunnel address changes." : "Publishing the computer's encrypted address\u2026";
-}
 var BASE = "https://api.oblien.com";
 var RENEW_BEFORE_MS = 24 * 60 * 6e4;
 var ProviderSignInRequired = class extends Error {
@@ -812,6 +692,19 @@ Waiting for sign-in\u2026`);
 // src/computer/provider-setup.ts
 var execute2 = promisify(execFile);
 async function chooseProvider(prompt) {
+  if (prompt.select) {
+    const selected = await prompt.select("Connection provider", [
+      { value: "automatic", label: "Automatic \xB7 Cloudflare + Mindwire recovery, no account" },
+      { value: "oblien", label: "Oblien \xB7 persistent address" },
+      { value: "cloudflare", label: "Cloudflare \xB7 your account and domain" },
+      { value: "ngrok", label: "ngrok \xB7 your account and reserved domain" },
+      { value: "vpn", label: "Your VPN \xB7 direct SSH" },
+      { value: "custom", label: "Existing secure tunnel" },
+      { value: "temporary", label: "Temporary Cloudflare \xB7 no address recovery" }
+    ]);
+    if (!selected) throw new Error("Connection setup cancelled.");
+    return selected;
+  }
   prompt.print("\nConnect this computer\n\n  1  Automatic \u2014 free Cloudflare tunnel + Mindwire address recovery, no account\n  2  Oblien \u2014 persistent address, browser sign-in\n  3  Cloudflare \u2014 your account and domain\n  4  ngrok \u2014 your account and reserved domain\n  5  Your VPN \u2014 direct SSH\n  6  Existing secure tunnel\n  7  Temporary Cloudflare connection \u2014 no address recovery\n");
   for (; ; ) {
     const answer = (await prompt.question("Connection [1]: ")).trim();
@@ -962,6 +855,81 @@ The token stays on this computer and is never sent to your phone.`);
     await lock?.close();
   }
 }
+var terminalText = (value) => value.replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+function accent(value) {
+  return process.stderr.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb" ? `\x1B[38;5;208m${value}\x1B[0m` : value;
+}
+async function chooseTerminal(title, choices) {
+  if (!choices.length) return;
+  if (!process.stdin.isTTY || !process.stderr.isTTY) throw new Error("Open mindwire in an interactive terminal, or use a command from mindwire --help.");
+  const input = process.stdin, output = process.stderr;
+  const wasRaw = !!input.isRaw, wasFlowing = input.readableFlowing === true;
+  emitKeypressEvents(input);
+  let selected = 0, lines = 0, finished = false;
+  const clear = () => {
+    if (lines) output.write(`\x1B[${lines}A\r\x1B[J`);
+    lines = 0;
+  };
+  const draw = () => {
+    clear();
+    const width = Math.max(8, (output.columns || 80) - 4);
+    const headings = typeof title === "string" ? [title] : title;
+    const visible = Math.max(1, Math.min(choices.length, (output.rows || 24) - headings.length - 4));
+    const first = Math.max(0, Math.min(selected - visible + 1, choices.length - visible));
+    const clip = (text) => {
+      const chars = [...terminalText(text)];
+      return chars.length > width ? chars.slice(0, width - 1).join("") + "\u2026" : chars.join("");
+    };
+    const rows = [
+      ...headings.map(clip),
+      ...choices.slice(first, first + visible).map((choice, index) => index + first === selected ? accent(`\u203A ${clip(choice.label)}`) : `  ${clip(choice.label)}`),
+      "",
+      clip("\u2191/\u2193 choose \xB7 Enter select \xB7 Esc back")
+    ];
+    output.write(rows.join("\n") + "\n");
+    lines = rows.length;
+  };
+  return await new Promise((resolve2, reject) => {
+    const cleanup = () => {
+      if (finished) return;
+      finished = true;
+      input.off("keypress", onKey);
+      input.off("end", onEnd);
+      output.off("resize", draw);
+      clear();
+      output.write("\x1B[?25h");
+      input.setRawMode(wasRaw);
+      if (!wasFlowing) input.pause();
+    };
+    const finish = (value) => {
+      cleanup();
+      resolve2(value);
+    };
+    const onEnd = () => finish();
+    const onKey = (_text, key) => {
+      if (key.name === "escape" || key.ctrl && ["c", "d"].includes(key.name ?? "")) return finish();
+      if (key.name === "return") return finish(choices[selected]?.value);
+      if (key.name === "up" || key.name === "k") selected = (selected + choices.length - 1) % choices.length;
+      else if (key.name === "down" || key.name === "j") selected = (selected + 1) % choices.length;
+      else return;
+      draw();
+    };
+    try {
+      input.setRawMode(true);
+      input.resume();
+      output.write("\x1B[?25l");
+      input.on("keypress", onKey);
+      input.once("end", onEnd);
+      output.on("resize", draw);
+      draw();
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+}
+
+// src/computer/setup-prompt.ts
 function openSetupURL(value) {
   const url = new URL(value);
   if (url.protocol !== "https:" || url.username || url.password) throw new Error("Invalid provider login URL.");
@@ -990,7 +958,7 @@ function question(text, hidden) {
       answered = true;
       input.close();
       if (hidden) process.stderr.write("\n");
-      resolve2(value.trim());
+      resolve2(hidden ? value : value.trim());
     });
   });
 }
@@ -1000,7 +968,8 @@ var terminalSetupPrompt = {
   print: (text) => {
     process.stderr.write(text + "\n");
   },
-  open: openSetupURL
+  open: openSetupURL,
+  select: chooseTerminal
 };
 var OblienTunnelLease = class {
   constructor(tunnelId, client, now = Date.now) {
@@ -1156,11 +1125,277 @@ async function runManagedRelay(file) {
     process.off("SIGINT", stop);
   }
 }
+async function inspectComputer(directory) {
+  const [config, controller, startup, preference, stopped, update, change] = await Promise.all([
+    readJSON(join(directory, "computer-config.json")),
+    readJSON(join(directory, "computer-controller.json")),
+    startupStatus(directory),
+    discoveryPreference(directory),
+    readJSON(join(directory, "computer-stopped.json")),
+    readJSON(join(directory, "computer-update.json")),
+    readJSON(join(directory, "computer-connection-change.json"))
+  ]);
+  const alive = await processStateAlive(controller).catch(() => false);
+  const result = {
+    name: hostname(),
+    cliVersion: SDK_VERSION,
+    service: !config ? "not-configured" : stopped?.stopped ? "stopped" : alive ? "starting" : "unavailable",
+    online: false,
+    startup,
+    discoveryPreference: preference,
+    devices: [],
+    update,
+    connection: config && connectionInfo(config.relay, config.host),
+    problem: controller?.error,
+    recoveryProblem: controller?.discoveryError,
+    recovering: controller?.recovering,
+    relayError: controller?.error,
+    relayErrorCode: controller?.errorCode,
+    connectionChange: change && { status: change.status, message: change.message }
+  };
+  if (!config || stopped?.stopped) return result;
+  try {
+    const client = await computerClient(directory);
+    const [info, health, work, devices] = await Promise.all([
+      client.computer.info(),
+      client.health(),
+      client.service.updateStatus(),
+      client.computer.devices()
+    ]);
+    return {
+      ...result,
+      service: "running",
+      online: alive && !!controller?.ready,
+      info,
+      daemonVersion: health.version,
+      activeOperations: work.activeOperations,
+      connection: info.connection ?? result.connection,
+      discovery: info.discovery,
+      devices
+    };
+  } catch {
+    return { ...result, problem: result.problem ?? (alive ? "The service is starting." : "The background service is not running.") };
+  }
+}
+function recoverySummary(state) {
+  if (state.discoveryPreference?.enabled === false) return "Off";
+  if (state.discovery?.enabled) {
+    if (state.discovery.error) return "Needs attention";
+    if (!state.discovery.sequence || state.discovery.sequence !== state.discovery.publishedSequence) return "Publishing address";
+    const saved = state.devices.filter((device) => !device.revoked);
+    if (saved.length && saved.some((device) => !device.addressRecovery)) return "Finish setup on your phone";
+    return "Ready";
+  }
+  if (state.connection?.address === "persistent") return "Persistent address";
+  if (state.connection?.provider === "direct") return "Direct / VPN";
+  if (state.recoveryProblem) return "Needs attention";
+  return state.discoveryPreference?.enabled ? "Setting up" : "Not set up";
+}
+function inspectionText(state, detailed = false) {
+  const devices = state.devices.filter((device) => !device.revoked);
+  const connected = devices.filter((device) => device.connected).length;
+  const running = state.service === "running";
+  const startup = state.startup.enabled ? state.startup.running ? "On" : "Needs repair" : "Off";
+  const lines = [
+    `Mindwire ${state.cliVersion} \xB7 ${state.name}`,
+    "",
+    `  Service        ${running ? `${state.daemonVersion} \xB7 running` : state.service.replaceAll("-", " ")}`,
+    `  Connection     ${state.online ? connected ? `${connected} phone${connected === 1 ? "" : "s"} connected` : "Ready for your phone" : "Offline"}`,
+    `  Auto reconnect ${recoverySummary(state)}`,
+    `  Start at login ${startup}`
+  ];
+  if (state.update && ["queued", "downloading", "waiting", "restarting"].includes(state.update.status)) {
+    lines.push(`  Update         ${state.update.version} \xB7 ${state.update.status === "waiting" ? `waiting for ${state.activeOperations ?? "active"} operation(s)` : state.update.status}`);
+  }
+  if (detailed) {
+    if (state.connection) lines.push(`  Carrier        ${state.connection.provider}`);
+    if (state.discovery?.url) lines.push(`  Directory      ${state.discovery.url}`);
+    if (state.info) {
+      lines.push(`  Service PID    ${state.info.pid}`, `  Computer       ${state.info.computerId}`, `  Host key       ${state.info.fingerprint}`);
+      for (const route of state.info.routes) lines.push(`  Address        ${route.kind === "ssh" ? `${route.host}:${route.port}` : route.url}`);
+    }
+    if (state.problem) lines.push("", state.problem);
+    if (state.recoveryProblem) lines.push("", state.recoveryProblem);
+    if (state.discovery?.error) lines.push("", state.discovery.error);
+    if (state.connectionChange?.status === "failed") lines.push("", state.connectionChange.message ?? "Connection provider change failed.");
+  }
+  return lines.map(terminalText).join("\n");
+}
+
+// src/computer/dashboard.ts
+async function computerDashboard(directory, run2) {
+  for (; ; ) {
+    const state = await inspectComputer(directory);
+    const saved = state.devices.filter((device) => !device.revoked);
+    const running = state.service === "running";
+    const action = await chooseTerminal([...inspectionText(state).split("\n"), "", "Manage this computer"], [
+      { value: "reconnect", label: running ? "Reconnect" : "Start connection" },
+      { value: "pair", label: "Pair or repair a phone" },
+      { value: "devices", label: `Phones${saved.length ? ` \xB7 ${saved.length} paired` : ""}` },
+      { value: "startup", label: `Start at login \xB7 ${state.startup.enabled ? state.startup.running ? "On" : "Needs repair" : "Off"}` },
+      { value: "connection", label: "Connection provider" },
+      ...process.platform === "darwin" ? [{ value: "desktop", label: "Desktop access" }] : [],
+      { value: "recovery", label: `Automatic reconnection \xB7 ${recoverySummary(state)}` },
+      { value: "update", label: activeUpdate(state.update) ? `Service update \xB7 ${state.update.status}` : "Update service" },
+      { value: "inspect", label: "Connection details" },
+      ...running ? [{ value: "stop", label: "Stop Mindwire" }] : [],
+      { value: "exit", label: "Exit" }
+    ]);
+    if (!action || action === "exit") return;
+    try {
+      switch (action) {
+        case "reconnect":
+          await run2(["reconnect"]);
+          break;
+        case "pair":
+          await run2(["connect", "pair"]);
+          break;
+        case "connection":
+          await run2(["connection"]);
+          break;
+        case "desktop":
+          await run2(["desktop"]);
+          break;
+        case "inspect":
+          await run2(["inspect"]);
+          break;
+        case "devices": {
+          if (!saved.length) {
+            process.stdout.write("No paired phones. Choose Pair or repair a phone to connect one.\n");
+            break;
+          }
+          const id = await chooseTerminal("Paired phones", saved.map((device2) => ({ value: device2.id, label: deviceSummary([device2], true).trim() })));
+          const device = saved.find((value) => value.id === id);
+          if (!device) break;
+          const decision = await chooseTerminal([
+            terminalText(device.name),
+            `Key ${terminalText(device.id)}`,
+            `Address recovery: ${device.addressRecovery ? "Ready" : "Open this phone to finish setup"}`,
+            ""
+          ], [{ value: "back", label: "Back" }, { value: "revoke", label: "Revoke access and disconnect this phone" }]);
+          if (decision === "revoke") await run2(["revoke", "--", id]);
+          break;
+        }
+        case "startup": {
+          const options = state.startup.enabled ? [{ value: "repair", label: "Repair automatic startup" }, { value: "disable", label: "Turn off automatic startup" }] : [{ value: "enable", label: "Start Mindwire when I sign in" }];
+          const choice = await chooseTerminal("Start at login", [...options, { value: "back", label: "Back" }]);
+          if (choice && choice !== "back") await run2(["startup", choice]);
+          break;
+        }
+        case "recovery": {
+          const enabled = state.discovery?.enabled;
+          const choice = await chooseTerminal([
+            "Automatic reconnection",
+            "Encrypted addresses only. No account needed.",
+            "Files, commands and chats stay inside your SSH connection.",
+            ""
+          ], [
+            { value: "enable", label: enabled ? "Check and repair address recovery" : "Enable address recovery" },
+            { value: "directory", label: "Use a self-hosted directory" },
+            ...enabled ? [{ value: "disable", label: "Turn off address recovery" }] : [],
+            { value: "back", label: "Back" }
+          ]);
+          if (choice === "directory") {
+            const url = await terminalSetupPrompt.question("Directory HTTPS URL: ");
+            if (url) await run2(["discovery", "enable", "--directory-url", url]);
+          } else if (choice === "enable") await run2(["discovery", "enable"]);
+          else if (choice === "disable") {
+            const decision = await chooseTerminal("A temporary address may need another scan after a restart.", [
+              { value: "back", label: "Keep automatic recovery" },
+              { value: "disable", label: "Turn off recovery" }
+            ]);
+            if (decision === "disable") await run2(["discovery", "disable"]);
+          }
+          break;
+        }
+        case "update":
+          await run2(["update"]);
+          break;
+        case "stop": {
+          const decision = await chooseTerminal(state.activeOperations ? "Stopping Mindwire closes its terminals and active sessions." : "Stop Mindwire until you choose Start again?", [
+            { value: "back", label: "Keep running" },
+            { value: "stop", label: "Stop Mindwire" }
+          ]);
+          if (decision === "stop") await run2(["stop", ...state.activeOperations ? ["--force"] : []]);
+          break;
+        }
+      }
+    } catch (error) {
+      process.stderr.write(`Mindwire: ${terminalText(error instanceof Error ? error.message : String(error))}
+`);
+    }
+    if (!await chooseTerminal("", [{ value: "continue", label: "Back to Mindwire" }])) return;
+  }
+}
+function desktopSummary(info) {
+  if (!info.supported) return "Desktop control is available on macOS.";
+  if (!info.enabled) return "Desktop access is off. Enable it with mindwire desktop enable.";
+  if (!info.screenSharing) return "Desktop access needs Screen Sharing. Run mindwire desktop enable to finish setup.";
+  return "Desktop access is on \xB7 paired SSH connection";
+}
+function openScreenSharingSettings() {
+  const child = spawn("/usr/bin/open", ["x-apple.systempreferences:com.apple.Sharing-Settings.extension?ScreenSharing"], { stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function manageDesktop(options) {
+  const { client, directory, interactive } = options;
+  const prompt = options.prompt ?? terminalSetupPrompt;
+  let action = options.action ?? (interactive ? "menu" : "status");
+  if (!["menu", "status", "enable", "disable"].includes(action)) throw new Error("Use mindwire desktop, or mindwire desktop enable, disable or status.");
+  let info = await client.surfaces.localStatus();
+  if (!info.supported) throw new Error("Desktop control is currently available on paired Macs.");
+  if (action === "menu") {
+    const choices = [
+      { value: "enable", label: info.enabled ? "Check setup or update Mac login" : "Enable desktop access" },
+      ...info.enabled ? [{ value: "disable", label: "Disable desktop access" }] : [],
+      { value: "status", label: "Back" }
+    ];
+    action = await prompt.select?.(desktopSummary(info), choices) ?? "status";
+  }
+  if (action === "status") return info;
+  if (action === "enable" && !interactive) throw new Error("Run mindwire desktop enable in an interactive terminal on your Mac. The password is entered privately there.");
+  const localToken = (await (options.readControlToken?.() ?? readFile(path.join(directory, "desktop-control.token"), "utf8"))).trim();
+  if (!/^[a-f0-9]{64}$/.test(localToken)) throw new Error("Update and restart Mindwire on this Mac before setting up desktop access.");
+  if (action === "disable") {
+    await client.surfaces.configureLocal({ enabled: false }, localToken);
+    if (!options.json) prompt.print("Desktop access is off. Its active viewers and controls were closed.\nApple Screen Sharing is unchanged; you can turn it off in Mac settings too.");
+    return client.surfaces.localStatus();
+  }
+  prompt.print("Desktop access\nYour paired phones can view and control this Mac. Agents still need desktop approval.\nThe display uses your existing encrypted SSH connection. The Mac login stays in Mindwire\u2019s private credentials on this Mac.");
+  const decision = prompt.select ? await prompt.select("Allow desktop access?", [
+    { value: "cancel", label: "Keep current settings" },
+    { value: "allow", label: "Allow desktop access" }
+  ]) : (await prompt.question("Allow desktop access? [y/N]: ")).toLowerCase() === "y" ? "allow" : "cancel";
+  if (decision !== "allow") return info;
+  while (!info.screenSharing) {
+    prompt.print(`In System Settings \u2192 General \u2192 Sharing, enable Screen Sharing.
+Allow only ${terminalText(info.username)}. Leave password-only VNC access off.`);
+    const choice = await prompt.select?.("Finish the Mac permission step", [
+      { value: "open", label: "Open Screen Sharing settings" },
+      { value: "check", label: "I enabled it \u2014 check again" },
+      { value: "cancel", label: "Cancel setup" }
+    ]) ?? "cancel";
+    if (choice === "cancel") return info;
+    if (choice === "open") {
+      (options.openSettings ?? openScreenSharingSettings)();
+      await prompt.question("Enable Screen Sharing, then press Return to check: ");
+    }
+    info = await client.surfaces.localStatus();
+  }
+  const password = await prompt.secret(`Mac password for ${terminalText(info.username)} (hidden): `);
+  if (!password || Buffer.byteLength(password) > 63 || password.includes("\0")) throw new Error("Enter your Mac password (up to 63 UTF-8 bytes). Desktop settings were not changed.");
+  await client.surfaces.configureLocal({ enabled: true, username: info.username, password }, localToken);
+  prompt.print("Desktop access is on. Open Desktop in Mindwire on your phone.\nTurn it off anytime with mindwire desktop disable.");
+  return client.surfaces.localStatus();
+}
 
 // src/cli.ts
 var help = `Mindwire \u2014 connect this computer to your phone
 
   npm install -g mindwire
+  mindwire                               Interactive status and connection controls
   mindwire connect                       Connect your phone; saved keys reconnect automatically
   mindwire reconnect                     Retry the saved connection
   mindwire connect pair                  Pair a phone, or repair a lost phone key/address
@@ -1179,12 +1414,17 @@ var help = `Mindwire \u2014 connect this computer to your phone
   mindwire connect --relay custom --relay-url wss://computer.example/ssh
 
   mindwire start                         Start the saved connection in the background
-  mindwire startup enable|disable        Manage automatic startup after computer login
+  mindwire startup enable|disable|repair Manage automatic startup after computer login
   mindwire startup status                Check automatic startup
   mindwire status                        Show connection and running service
+  mindwire inspect                       Connection details, recovery and diagnostics
   mindwire devices                       List paired phones
+  mindwire desktop                       Desktop status and Mac permission setup
+  mindwire desktop enable|disable        Allow or stop desktop access from this Mac
+  mindwire desktop status                Check desktop setup
   mindwire revoke DEVICE_ID              Disconnect and revoke one phone
   mindwire update [--version VERSION]     Download a verified release; wait until idle
+  mindwire update --force                 Restart now, closing active terminals and sessions
   mindwire stop                          Stop when no work or terminals are running
 
 Options:
@@ -1215,6 +1455,10 @@ function safeName(text) {
   return text.replace(/[\x00-\x1f\x7f-\x9f]/g, "");
 }
 async function main(args = process.argv.slice(2)) {
+  if (args.some((value) => ["--version", "-v", "version"].includes(value)) && args.every((value) => ["--version", "-v", "version", "--json"].includes(value))) {
+    process.stdout.write(args.includes("--json") ? JSON.stringify({ version: SDK_VERSION }) + "\n" : SDK_VERSION + "\n");
+    return;
+  }
   const { values, positionals } = parseArgs({ args, allowPositionals: true, options: {
     help: { type: "boolean", short: "h" },
     json: { type: "boolean" },
@@ -1241,11 +1485,14 @@ async function main(args = process.argv.slice(2)) {
     "no-startup": { type: "boolean" },
     "replace-device": { type: "string", multiple: true }
   } });
-  const command = positionals[0] ?? "help";
+  const interactive = !values.json && !!process.stdin.isTTY && !!process.stderr.isTTY && process.env.TERM !== "dumb";
+  const command = positionals[0] ?? (interactive ? "dashboard" : "help");
   if (values.help || command === "help") {
     process.stdout.write(help);
     return;
   }
+  if (!["dashboard", "connect", "start", "reconnect", "connection", "startup", "discovery", "desktop", "status", "inspect", "devices", "revoke", "approve", "reject", "update", "stop", "_serve", "_watch", "_relay"].includes(command))
+    throw new Error(`Unknown command ${safeName(command)}. Run mindwire --help.`);
   if (values.qr && !["auto", "terminal", "browser"].includes(values.qr)) throw new Error("Choose --qr auto, terminal or browser.");
   if (values.startup && values["no-startup"]) throw new Error("Choose either --startup or --no-startup.");
   const directory = path.resolve(values["state-dir"] ?? defaultStateDirectory());
@@ -1254,6 +1501,29 @@ async function main(args = process.argv.slice(2)) {
     if (values.json) process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
     else if (text) process.stdout.write(text + "\n");
   };
+  if (command === "desktop") {
+    if (process.platform !== "darwin") throw new Error("Desktop setup is currently available on macOS. Your other Mindwire features are unchanged.");
+    const client2 = await computerClient(directory, 3e4);
+    const health = await client2.health();
+    if ((health.localDesktopVersion ?? 0) < 1) throw new Error("Update the Mindwire service on this Mac before setting up desktop access: mindwire update");
+    const info = await manageDesktop({ client: client2, directory, action: positionals[1], interactive, json: values.json });
+    emit("desktop", info, desktopSummary(info));
+    return;
+  }
+  if (command === "dashboard") {
+    await computerDashboard(directory, (next) => main([
+      "--state-dir",
+      directory,
+      ...values["directory-url"] && !next.includes("--directory-url") ? ["--directory-url", values["directory-url"]] : [],
+      ...next
+    ]));
+    return;
+  }
+  if (command === "status" || command === "inspect") {
+    const state = await inspectComputer(directory);
+    emit(command, { ...state.info, ...state, idle: state.activeOperations === 0 }, inspectionText(state, command === "inspect"));
+    return;
+  }
   if (command === "_serve") {
     await superviseComputer(directory);
     return;
@@ -1269,23 +1539,23 @@ async function main(args = process.argv.slice(2)) {
   }
   if (command === "startup") {
     const action = positionals[1] ?? "status";
-    if (!["enable", "disable", "status"].includes(action)) throw new Error("Use mindwire startup enable, disable or status.");
-    const state = action === "status" ? await startupStatus(directory) : await configureStartup(directory, fileURLToPath(import.meta.url), action === "enable");
-    emit("startup", state, state.enabled ? "Mindwire starts after you sign in to this computer and recovers automatically." : "Automatic startup is off. Use mindwire start to run the service.");
+    if (!["enable", "disable", "repair", "status"].includes(action)) throw new Error("Use mindwire startup enable, disable, repair or status.");
+    const state = action === "status" ? await startupStatus(directory) : await configureStartup(directory, fileURLToPath(import.meta.url), action !== "disable", { repair: action === "repair" });
+    emit("startup", state, state.enabled ? state.running ? "Mindwire starts after you sign in to this computer." : "Automatic startup needs repair. Run mindwire startup repair." : "Automatic startup is off. Use mindwire start to run the service.");
     return;
   }
   if (command === "discovery") {
     const action = positionals[1] ?? "status";
     if (!["enable", "disable", "status"].includes(action)) throw new Error("Use mindwire discovery enable, disable or status.");
     const client2 = action === "status" ? await computerClient(directory) : await ensureComputer(directory, fileURLToPath(import.meta.url), {}, void 0, { waitForRoutes: false });
-    const status = action === "enable" ? await enableAddressDiscovery({ directory, computer: client2, prompt: terminalSetupPrompt, ...discoveryOptions }) : action === "disable" ? await client2.computer.configureDiscovery(false) : await client2.computer.discovery();
+    const status = action === "enable" ? await enableAddressDiscovery({ directory, computer: client2, prompt: terminalSetupPrompt, ...discoveryOptions }) : action === "disable" ? await disableAddressDiscovery(directory, client2) : await client2.computer.discovery();
     emit("discovery", status, discoveryDescription(status));
     if (action === "enable") emit("discovery_hint", {}, "Open each saved phone once while its current address works. Pair new phones with mindwire connect pair.");
     return;
   }
   if (["connect", "start", "reconnect", "connection"].includes(command)) {
     let requestedAction = command === "reconnect" ? "reconnect" : command === "connect" ? connectionAction(positionals[1]) : void 0;
-    let automaticDiscovery = false, addressChanged = false;
+    let automaticDiscovery = false, temporaryConnection = false, addressChanged = false;
     const patch = {};
     const previous = await readJSON(path.join(directory, "computer-config.json"));
     if (values.directory) patch.directory = path.resolve(values.directory);
@@ -1299,7 +1569,10 @@ async function main(args = process.argv.slice(2)) {
       }
     }
     if (values["daemon-bin"] || process.env.MINDWIRE_DAEMON) patch.daemonBin = path.resolve(values["daemon-bin"] ?? process.env.MINDWIRE_DAEMON);
-    if (values.version) patch.version = values.version.replace(/^v/, "");
+    if (values.version) {
+      patch.version = values.version.replace(/^v/, "");
+      if (!previous) patch.versionPinned = true;
+    }
     if (values.relay || values["relay-url"] || values["cloudflare-token-file"] || values["ngrok-token-file"] || values["oblien-credentials-file"]) {
       const kind = values.relay ?? "custom";
       if (!["none", "oblien", "cloudflare", "ngrok", "custom"].includes(kind)) throw new Error("Choose relay none, oblien, cloudflare, ngrok or custom.");
@@ -1314,7 +1587,6 @@ async function main(args = process.argv.slice(2)) {
         oblienTunnelId: tunnelId
       };
     }
-    const interactive = !values.json && !!process.stdin.isTTY;
     const needsSetup = command === "connection" || command === "connect" && !previous && !patch.relay && interactive || patch.relay?.kind === "oblien" && !patch.relay.oblienCredentialsFile;
     if (needsSetup) {
       const selected = command === "connection" && positionals[1] ? connectionProvider(positionals[1]) : void 0;
@@ -1322,6 +1594,7 @@ async function main(args = process.argv.slice(2)) {
         throw new Error("Run mindwire connection in an interactive terminal, or supply the provider's saved URL and credential-file options.");
       const provider = selected ?? (patch.relay?.kind === "oblien" ? "oblien" : await chooseProvider(terminalSetupPrompt));
       automaticDiscovery = provider === "automatic";
+      temporaryConnection = provider === "temporary";
       Object.assign(patch, await setupProvider({
         directory,
         provider,
@@ -1330,6 +1603,11 @@ async function main(args = process.argv.slice(2)) {
       }));
       if (!previous || connectionAddress(patch.relay ?? previous.relay, patch.host ?? previous.host) !== connectionAddress(previous.relay, previous.host)) addressChanged = true;
     }
+    if (temporaryConnection) await saveDiscoveryPreference(directory, { enabled: false });
+    if (automaticDiscovery) await saveDiscoveryPreference(directory, {
+      enabled: true,
+      url: values["directory-url"] ?? (await discoveryPreference(directory))?.url
+    });
     if (automaticDiscovery && previous) {
       const running = await ensureComputer(directory, fileURLToPath(import.meta.url), {}, void 0, { waitForRoutes: false });
       await enableAddressDiscovery({ directory, computer: running, prompt: terminalSetupPrompt, ...discoveryOptions });
@@ -1340,12 +1618,17 @@ async function main(args = process.argv.slice(2)) {
       if (progress) progress.update(phase);
       else emit("progress", { message: phase }, phase);
     }).finally(() => progress?.close());
-    if (automaticDiscovery && !previous) await enableAddressDiscovery({ directory, computer: client2, prompt: terminalSetupPrompt, ...discoveryOptions });
-    const info = await client2.computer.info();
     const savedConfig = await readJSON(path.join(directory, "computer-config.json"));
+    try {
+      if (temporaryConnection) await disableAddressDiscovery(directory, client2);
+      else if (savedConfig) await reconcileAddressDiscovery({ directory, config: savedConfig, computer: client2 });
+    } catch (error) {
+      emit("recovery_pending", {}, `Automatic reconnection: ${safeName(error instanceof Error ? error.message : "Setup will retry in the background.")}`);
+    }
+    const info = await client2.computer.info();
     const connection = connectionInfo(savedConfig?.relay ?? { kind: "cloudflare" }, savedConfig?.host);
     emit("ready", { computerId: info.computerId, routes: info.routes, connection }, "Mindwire is running in the background.");
-    emit("connection", connection, connectionDescription(connection));
+    emit("connection", connection, info.discovery?.enabled && connection.address === "temporary" ? "Cloudflare \xB7 encrypted Mindwire address recovery" : connectionDescription(connection));
     if (command === "start") return;
     if (info.routes.some((route) => route.kind === "websocket")) {
       emit("secure_connection", {}, "Your phone connects over end-to-end encrypted SSH. The tunnel carries encrypted traffic; only phones you approve can connect.");
@@ -1381,7 +1664,7 @@ ${deviceSummary(saved)}`);
         emit("startup_unavailable", {}, "Mindwire is running, but startup setup didn't complete. Run mindwire startup enable to check your system's startup service.");
       }
     } else {
-      emit("startup", startupPreference, startupPreference.enabled ? "Automatic startup is on. Change it with mindwire startup disable." : "Automatic startup is off. Enable it with mindwire startup enable.");
+      emit("startup", startupPreference, startupPreference.enabled ? startupPreference.running ? "Automatic startup is on. Change it with mindwire startup disable." : "Automatic startup needs repair. Run mindwire startup repair." : "Automatic startup is off. Enable it with mindwire startup enable.");
     }
     if (action === "resume") {
       const connected = saved.filter((device) => device.connected);
@@ -1473,42 +1756,30 @@ ${command2}`);
     emit("stopped", {}, "Mindwire stopped.");
     return;
   }
-  const client = await computerClient(directory);
-  switch (command) {
-    case "status": {
-      const [info, health, work, controller, startup, config, change] = await Promise.all([
-        client.computer.info(),
-        client.health(),
-        client.service.updateStatus(),
-        readJSON(path.join(directory, "computer-controller.json")),
-        startupStatus(directory),
-        readJSON(path.join(directory, "computer-config.json")),
-        readJSON(path.join(directory, "computer-connection-change.json"))
+  if (command === "update") {
+    const client2 = await ensureComputer(directory, fileURLToPath(import.meta.url), {}, void 0, { waitForRoutes: false });
+    let force = values.force === true;
+    if (interactive && !force && !(await client2.service.updateStatus()).idle) {
+      const choice = await chooseTerminal("An update can restart Mindwire while work is open.", [
+        { value: "wait", label: "Update when idle" },
+        { value: "restart", label: "Restart now \u2014 close terminals and active sessions" },
+        { value: "cancel", label: "Cancel" }
       ]);
-      const connection = info.connection ?? (config && connectionInfo(config.relay, config.host));
-      const connectionChange = change && { status: change.status, message: change.message };
-      emit(
-        "status",
-        {
-          ...info,
-          connection,
-          daemonVersion: health.version,
-          ...work,
-          startup,
-          connectionChange,
-          recovering: controller?.recovering,
-          relayError: controller?.error,
-          relayErrorCode: controller?.errorCode
-        },
-        `Mindwire ${health.version} \xB7 ${work.idle ? "idle" : "working"}
-Startup: ${startup.enabled ? "on" : "off"}
-${connection ? connectionDescription(connection) + "\n" : ""}${info.routes.map((route) => route.kind === "ssh" ? `SSH ${route.host}:${route.port}` : route.url).join("\n")}${controller?.error ? `
-${controller.error}` : ""}${change && change.status !== "complete" ? `
-Connection change: ${change.status}${change.message ? " \xB7 " + change.message : ""}` : ""}`
-      );
-      if (info.discovery?.enabled && !values.json) emit("discovery", info.discovery, discoveryDescription(info.discovery));
-      break;
+      if (!choice || choice === "cancel") return;
+      force = choice === "restart";
     }
+    const result = await updateComputer({
+      directory,
+      version: values.version ?? SDK_VERSION,
+      force,
+      allowDowngrade: !!values.version,
+      onProgress: (update) => emit("update", update, updateProgress(update))
+    });
+    emit(result.complete ? "updated" : "update_pending", result, result.complete ? `Mindwire service ${result.version} is installed.` : `${result.update?.version} is ${result.update?.status === "waiting" ? "waiting for active work to finish" : "updating in the background"}.${result.update?.version !== result.version ? ` Run mindwire update again after it completes to check ${result.version}.` : " You can close this terminal."} Run mindwire inspect for status.`);
+    return;
+  }
+  const client = await computerClient(directory);
+  switch (command) {
     case "devices": {
       const devices = await client.computer.devices();
       emit("devices", { devices }, devices.length ? devices.map((d) => `${safeName(d.name)}  ${d.id}${d.revoked ? "  (revoked)" : ""}`).join("\n") : "No paired phones yet. Run mindwire connect.");
@@ -1532,28 +1803,6 @@ Connection change: ${change.status}${change.message ? " \xB7 " + change.message
       emit(command, {}, command === "approve" ? "Phone approved. Waiting for it to save the connection." : "Phone declined.");
       break;
     }
-    case "update": {
-      const version = (values.version ?? SDK_VERSION).replace(/^v/, "");
-      const health = await client.health();
-      if (health.version.replace(/^v/, "") === version) {
-        emit("updated", { version }, `Mindwire ${version} is already installed.`);
-        return;
-      }
-      const requested = await client.computer.requestUpdate(version);
-      emit("update_queued", requested, "Update queued. It will wait until all work and terminals are finished.");
-      let last = "";
-      for (; ; ) {
-        const update = await readJSON(path.join(directory, "computer-update.json"));
-        if (update?.id !== requested.id) throw new Error("The update request changed. Run mindwire status.");
-        if (update.status !== last) {
-          last = update.status;
-          emit("update", update, `Update: ${update.status}`);
-        }
-        if (update.status === "complete") return;
-        if (update.status === "failed") throw new Error(update.error ?? "Update failed.");
-        await setTimeout$1(750);
-      }
-    }
     default:
       throw new Error(`Unknown command ${command}. Run mindwire --help.`);
   }