@remodex/rmx 1.0.3 → 1.0.4

package/src/cli/onboard.ts

@@ -0,0 +1,599 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createAndroidRemoteStore } from "../android-remote/store";
+import { ensureConfigFile } from "../config";
+import {
+  currentExternalCodexModelProvider,
+  getCodexConfigPath,
+} from "../codex/inject";
+import {
+  setIntegrationEnabled,
+  type CodexDesiredStateResult,
+} from "../codex/desired-state";
+import { syncModelsToCodex, type CodexSyncResult } from "../codex/sync";
+import { openUrl } from "../lib/open-url";
+import {
+  assertServiceEnvironmentMatchesInstall,
+  diagnoseService,
+  type ServiceDiagnostic,
+} from "../service";
+import {
+  findLiveProxy,
+  probeHostname,
+  type LiveProxy,
+} from "../server/proxy-liveness";
+import {
+  getWindowsTrayStatusAsync,
+  type WindowsTrayStatus,
+} from "../tray/windows";
+import { runtimeRequest } from "./runtime-api";
+
+export const ONBOARD_USAGE = "rmx onboard [--verbose] [--json] [--no-open]";
+const ONBOARD_STEPS = 6;
+const DEFAULT_PROXY_WAIT_MS = 45_000;
+const DEFAULT_TUNNEL_WAIT_MS = 180_000;
+const CAPTURE_LIMIT = 96 * 1024;
+
+export type OnboardOptions = {
+  verbose: boolean;
+  json: boolean;
+  noOpen: boolean;
+};
+
+export type OnboardParseResult =
+  | { ok: true; options: OnboardOptions }
+  | { ok: false; message: string };
+
+export type CapturedCommand = {
+  code: number;
+  stdout: string;
+  stderr: string;
+};
+
+export type OnboardRemoteStatus = {
+  controlEnabled: boolean;
+  pairingAvailable: boolean;
+  gateway: {
+    status: "stopped" | "starting" | "ready" | "error";
+    error?: string;
+  };
+  tunnel: {
+    configuration: {
+      mode: "quick" | "named";
+      namedHostname?: string;
+      hasNamedTunnelToken: boolean;
+    };
+    runtime: {
+      mode: "quick" | "named";
+      status: "stopped" | "starting" | "checking" | "ready" | "error";
+      publicUrl: string | null;
+      error: "cloudflared_unavailable" | "named_tunnel_incomplete" | "tunnel_failed" | "verification_failed" | null;
+    };
+  };
+};
+
+type OnboardOutput = Pick<Console, "log" | "error">;
+
+export interface OnboardDeps {
+  platform?: NodeJS.Platform;
+  output?: OnboardOutput;
+  codexConfigExists?: () => boolean;
+  assertServiceOwnership?: () => void;
+  externalProvider?: () => string | null;
+  ensureConfig?: typeof ensureConfigFile;
+  enableCodex?: () => CodexDesiredStateResult;
+  configureAndroidRemote?: () => { mode: "quick" | "named"; hostname?: string };
+  diagnoseService?: () => ServiceDiagnostic;
+  runSubcommand?: (args: string[]) => Promise<CapturedCommand>;
+  trayStatus?: () => Promise<WindowsTrayStatus>;
+  findLive?: () => Promise<LiveProxy | null>;
+  applyAndroidRemote?: (baseUrl: string) => Promise<OnboardRemoteStatus>;
+  readAndroidRemote?: (baseUrl: string) => Promise<OnboardRemoteStatus>;
+  syncCodex?: (
+    port: number,
+    log: Pick<Console, "log" | "error"> | null,
+  ) => Promise<CodexSyncResult>;
+  open?: (url: string) => void;
+  sleep?: (milliseconds: number) => Promise<void>;
+  now?: () => number;
+  proxyWaitMs?: number;
+  tunnelWaitMs?: number;
+}
+
+export type OnboardResult = {
+  ok: boolean;
+  code: 0 | 1;
+  completedSteps: number;
+  platform: NodeJS.Platform;
+  provider: string | null;
+  codex: string | null;
+  service: "ready" | null;
+  tray: "ready" | "not-applicable" | null;
+  tunnel: {
+    mode: "quick" | "named";
+    status: "verified";
+    publicUrl: string;
+  } | null;
+  dashboardUrl: string | null;
+  error?: string;
+};
+
+class OnboardStepError extends Error {
+  constructor(
+    message: string,
+    readonly diagnostic?: string,
+  ) {
+    super(message);
+    this.name = "OnboardStepError";
+  }
+}
+
+function appendCaptured(current: string, value: unknown): string {
+  return `${current}${String(value)}`.slice(-CAPTURE_LIMIT);
+}
+
+/** Run an existing CLI command without leaking its routine output into onboarding. */
+export function runCapturedCli(args: string[]): Promise<CapturedCommand> {
+  return new Promise(resolve => {
+    const cli = process.argv[1];
+    if (!cli) {
+      resolve({ code: 1, stdout: "", stderr: "Could not resolve the Remodex CLI entry point." });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = spawn(process.execPath, [cli, ...args], {
+      cwd: process.cwd(),
+      env: process.env,
+      shell: false,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    child.stdout?.on("data", chunk => { stdout = appendCaptured(stdout, chunk); });
+    child.stderr?.on("data", chunk => { stderr = appendCaptured(stderr, chunk); });
+    child.once("error", error => {
+      if (settled) return;
+      settled = true;
+      resolve({ code: 1, stdout, stderr: appendCaptured(stderr, error.message) });
+    });
+    child.once("close", code => {
+      if (settled) return;
+      settled = true;
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+
+export function parseOnboardArgs(argv: string[]): OnboardParseResult {
+  const options: OnboardOptions = { verbose: false, json: false, noOpen: false };
+  for (const arg of argv) {
+    if (arg === "--verbose") options.verbose = true;
+    else if (arg === "--json") options.json = true;
+    else if (arg === "--no-open") options.noOpen = true;
+    else return { ok: false, message: `Unknown onboard option: ${arg}` };
+  }
+  // A machine-readable run must not launch a browser as an undocumented side effect.
+  if (options.json) options.noOpen = true;
+  return { ok: true, options };
+}
+
+function platformLabel(platform: NodeJS.Platform): string {
+  if (platform === "win32") return "Windows";
+  if (platform === "darwin") return "macOS";
+  if (platform === "linux") return "Linux";
+  return platform;
+}
+
+function safeTerminalValue(value: string): string {
+  return value.replace(/[\u0000-\u001f\u007f]/gu, " ").trim().slice(0, 96);
+}
+
+function defaultConfigureAndroidRemote(): { mode: "quick" | "named"; hostname?: string } {
+  const store = createAndroidRemoteStore();
+  const current = store.read();
+  const state = current.settings.controlEnabled
+    ? current
+    : store.updateSettings({ controlEnabled: true });
+  return {
+    mode: state.settings.tunnelMode,
+    ...(state.settings.tunnelMode === "named" && state.settings.namedTunnelHostname
+      ? { hostname: state.settings.namedTunnelHostname }
+      : {}),
+  };
+}
+
+async function defaultApplyAndroidRemote(baseUrl: string): Promise<OnboardRemoteStatus> {
+  return runtimeRequest<OnboardRemoteStatus>("/api/android-remote/settings", {
+    method: "PUT",
+    body: JSON.stringify({ controlEnabled: true }),
+  }, { baseUrl });
+}
+
+async function defaultReadAndroidRemote(baseUrl: string): Promise<OnboardRemoteStatus> {
+  return runtimeRequest<OnboardRemoteStatus>("/api/android-remote", {}, { baseUrl });
+}
+
+function indentedOutput(output: OnboardOutput): Pick<Console, "log" | "error"> {
+  return {
+    log: value => output.log(`      ${String(value)}`),
+    error: value => output.error(`      ${String(value)}`),
+  };
+}
+
+function commandDiagnostic(result: CapturedCommand): string {
+  return [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n").slice(-CAPTURE_LIMIT);
+}
+
+async function runRequiredSubcommand(
+  args: string[],
+  run: (args: string[]) => Promise<CapturedCommand>,
+  options: OnboardOptions,
+  output: OnboardOutput,
+): Promise<void> {
+  const result = await run(args);
+  const diagnostic = commandDiagnostic(result);
+  if (options.verbose) {
+    output.log(`      $ rmx ${args.join(" ")}`);
+    if (diagnostic) {
+      for (const line of diagnostic.split(/\r?\n/u)) output.log(`        ${line}`);
+    }
+  }
+  if (result.code !== 0) {
+    throw new OnboardStepError(
+      `The command 'rmx ${args.join(" ")}' did not complete.`,
+      diagnostic || `Command exited with status ${result.code}.`,
+    );
+  }
+}
+
+async function waitForLiveProxy(
+  find: () => Promise<LiveProxy | null>,
+  sleep: (milliseconds: number) => Promise<void>,
+  now: () => number,
+  timeoutMs: number,
+): Promise<LiveProxy> {
+  const deadline = now() + timeoutMs;
+  let lastError: unknown;
+  do {
+    try {
+      const live = await find();
+      if (live) return live;
+    } catch (error) {
+      lastError = error;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) break;
+    await sleep(Math.min(500, remaining));
+  } while (now() < deadline);
+  throw new OnboardStepError(
+    "The background service was installed, but the local Remodex server did not become healthy.",
+    lastError instanceof Error ? lastError.message : undefined,
+  );
+}
+
+function tunnelWaitMessage(status: OnboardRemoteStatus): string {
+  const runtime = status.tunnel.runtime;
+  if (status.gateway.status === "error") {
+    return status.gateway.error
+      ? `The Android gateway could not start: ${safeTerminalValue(status.gateway.error)}`
+      : "The Android gateway could not start.";
+  }
+  if (runtime.error === "named_tunnel_incomplete") {
+    return "The saved custom domain needs both a hostname and connector token. Complete it in Android Remote, then retry.";
+  }
+  if (runtime.error === "cloudflared_unavailable") {
+    return "Cloudflared could not be installed or started. Check the network connection, then retry.";
+  }
+  if (runtime.error === "tunnel_failed") {
+    return "The Cloudflare Tunnel stopped before its public connection could be verified.";
+  }
+  if (runtime.status === "checking" || runtime.error === "verification_failed") {
+    return "Cloudflare did not verify the public address in time. Remodex kept the unverified link hidden; retry after propagation finishes.";
+  }
+  return "The Cloudflare Tunnel did not produce a verified public connection in time.";
+}
+
+async function waitForVerifiedTunnel(
+  baseUrl: string,
+  expectedMode: "quick" | "named",
+  read: (baseUrl: string) => Promise<OnboardRemoteStatus>,
+  sleep: (milliseconds: number) => Promise<void>,
+  now: () => number,
+  timeoutMs: number,
+  onTransition: (status: OnboardRemoteStatus["tunnel"]["runtime"]["status"]) => void,
+): Promise<OnboardRemoteStatus> {
+  const deadline = now() + timeoutMs;
+  let lastStatus: OnboardRemoteStatus | null = null;
+  let lastReadError: unknown;
+  let observed: OnboardRemoteStatus["tunnel"]["runtime"]["status"] | null = null;
+  do {
+    try {
+      const status = await read(baseUrl);
+      lastStatus = status;
+      lastReadError = null;
+      const runtime = status.tunnel.runtime;
+      if (runtime.status !== observed) {
+        observed = runtime.status;
+        onTransition(runtime.status);
+      }
+      if (status.gateway.status === "error" || runtime.error === "named_tunnel_incomplete") {
+        throw new OnboardStepError(tunnelWaitMessage(status));
+      }
+      if (runtime.mode === expectedMode
+        && runtime.status === "ready"
+        && typeof runtime.publicUrl === "string"
+        && runtime.publicUrl.startsWith("https://")
+        && status.controlEnabled
+        && status.pairingAvailable) {
+        return status;
+      }
+    } catch (error) {
+      if (error instanceof OnboardStepError) throw error;
+      lastReadError = error;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) break;
+    await sleep(Math.min(1_000, remaining));
+  } while (now() < deadline);
+
+  throw new OnboardStepError(
+    lastStatus ? tunnelWaitMessage(lastStatus) : "Android Remote status could not be read from the local server.",
+    lastReadError instanceof Error ? lastReadError.message : undefined,
+  );
+}
+
+function routingSummary(result: CodexSyncResult, provider: string | null): string {
+  if (result.routingApplied === true) return "Connected through Remodex";
+  if (provider) return `${safeTerminalValue(provider)} preserved`;
+  return "Existing Codex routing preserved";
+}
+
+function failureResult(
+  completedSteps: number,
+  platform: NodeJS.Platform,
+  provider: string | null,
+  codex: string | null,
+  service: "ready" | null,
+  tray: "ready" | "not-applicable" | null,
+  dashboardUrl: string | null,
+  error: string,
+): OnboardResult {
+  return {
+    ok: false,
+    code: 1,
+    completedSteps,
+    platform,
+    provider,
+    codex,
+    service,
+    tray,
+    tunnel: null,
+    dashboardUrl,
+    error,
+  };
+}
+
+export async function runOnboard(
+  options: OnboardOptions,
+  deps: OnboardDeps = {},
+): Promise<OnboardResult> {
+  const platform = deps.platform ?? process.platform;
+  const output = deps.output ?? console;
+  const sleep = deps.sleep ?? (milliseconds => Bun.sleep(milliseconds));
+  const now = deps.now ?? Date.now;
+  const ensureConfig = deps.ensureConfig ?? ensureConfigFile;
+  const enableCodex = deps.enableCodex ?? (() => setIntegrationEnabled("codex", true));
+  const configureAndroidRemote = deps.configureAndroidRemote ?? defaultConfigureAndroidRemote;
+  const serviceDiagnostic = deps.diagnoseService ?? diagnoseService;
+  const runSubcommand = deps.runSubcommand ?? runCapturedCli;
+  const findLive = deps.findLive ?? (() => findLiveProxy());
+  const applyAndroidRemote = deps.applyAndroidRemote ?? defaultApplyAndroidRemote;
+  const readAndroidRemote = deps.readAndroidRemote ?? defaultReadAndroidRemote;
+  const syncCodex = deps.syncCodex ?? ((port, log) => syncModelsToCodex(port, undefined, log));
+  const trayStatus = deps.trayStatus ?? getWindowsTrayStatusAsync;
+  const open = deps.open ?? openUrl;
+  let completedSteps = 0;
+  let provider: string | null = null;
+  let codex: string | null = null;
+  let service: "ready" | null = null;
+  let tray: "ready" | "not-applicable" | null = platform === "win32" ? null : "not-applicable";
+  let dashboardUrl: string | null = null;
+
+  const begin = (step: number, title: string): void => {
+    if (!options.json) output.log(`[${step}/${ONBOARD_STEPS}] ${title}`);
+  };
+  const complete = (step: number, detail: string): void => {
+    completedSteps = step;
+    if (!options.json) output.log(`      ${detail}\n`);
+  };
+
+  if (!options.json) output.log("Setting up Remodex\n");
+
+  try {
+    begin(1, "Checking this computer");
+    (deps.assertServiceOwnership ?? assertServiceEnvironmentMatchesInstall)();
+    const codexExists = (deps.codexConfigExists ?? (() => existsSync(getCodexConfigPath())))();
+    if (!codexExists) {
+      throw new OnboardStepError("Codex settings were not found. Open Codex once, finish sign-in, then retry.");
+    }
+    provider = (deps.externalProvider ?? currentExternalCodexModelProvider)();
+    complete(1, `${platformLabel(platform)} · Codex found`);
+
+    begin(2, "Configuring Remodex");
+    const bootstrap = ensureConfig();
+    if (bootstrap.status === "invalid") {
+      throw new OnboardStepError("Remodex config.json is malformed. It was preserved; repair it before retrying.");
+    }
+    let desired = enableCodex();
+    if (!desired.ok && desired.retryable) desired = enableCodex();
+    if (!desired.ok) throw new OnboardStepError(desired.message);
+    complete(2, provider
+      ? `Existing provider: ${safeTerminalValue(provider)} · preserved`
+      : "Safe defaults ready");
+
+    begin(3, "Preparing Android Remote");
+    const android = configureAndroidRemote();
+    complete(3, android.mode === "quick"
+      ? "Quick Tunnel selected"
+      : `Custom domain preserved${android.hostname ? ` · ${safeTerminalValue(android.hostname)}` : ""}`);
+
+    begin(4, "Starting background service");
+    let diagnosed = serviceDiagnostic();
+    if (!diagnosed.supported) {
+      throw new OnboardStepError(`A background service is unavailable on this system: ${safeTerminalValue(diagnosed.summary)}`);
+    }
+    if (diagnosed.conflict) {
+      throw new OnboardStepError("Two background-service backends are installed. Resolve the conflict shown by 'rmx service status', then retry.");
+    }
+    if (!diagnosed.installed) {
+      await runRequiredSubcommand(["service", "install"], runSubcommand, options, output);
+    } else if (!diagnosed.viable) {
+      await runRequiredSubcommand(["service", "repair"], runSubcommand, options, output);
+    }
+    diagnosed = serviceDiagnostic();
+    if (!diagnosed.installed || diagnosed.stale || diagnosed.conflict) {
+      throw new OnboardStepError("The background-service registration is not healthy after setup.", diagnosed.summary);
+    }
+    let live: LiveProxy;
+    try {
+      live = await waitForLiveProxy(
+        findLive,
+        sleep,
+        now,
+        deps.proxyWaitMs ?? DEFAULT_PROXY_WAIT_MS,
+      );
+    } catch (error) {
+      if (!(error instanceof OnboardStepError) || !diagnosed.viable) throw error;
+      if (!options.json) output.log("      Service did not answer. Restarting once…");
+      await runRequiredSubcommand(["service", "repair"], runSubcommand, options, output);
+      diagnosed = serviceDiagnostic();
+      if (!diagnosed.installed || !diagnosed.viable || diagnosed.stale || diagnosed.conflict) {
+        throw new OnboardStepError("The background service is still unhealthy after one restart.", diagnosed.summary);
+      }
+      live = await waitForLiveProxy(
+        findLive,
+        sleep,
+        now,
+        deps.proxyWaitMs ?? DEFAULT_PROXY_WAIT_MS,
+      );
+    }
+    const host = probeHostname(live.hostname);
+    const displayHost = host === "127.0.0.1" ? "localhost" : host;
+    const baseUrl = `http://${host}:${live.port}`;
+    dashboardUrl = `http://${displayHost}:${live.port}/#android-remote/pair`;
+    await applyAndroidRemote(baseUrl);
+
+    if (platform === "win32") {
+      let status = await trayStatus();
+      if (!status.supported) throw new OnboardStepError("The Windows tray is unavailable on this installation.");
+      if (!status.installed || !status.running || status.stale) {
+        await runRequiredSubcommand(["tray", "install"], runSubcommand, options, output);
+        status = await trayStatus();
+      }
+      if (!status.installed || !status.running || status.stale) {
+        throw new OnboardStepError("The Windows tray did not become ready after installation.", status.summary);
+      }
+      tray = "ready";
+    }
+    service = "ready";
+    complete(4, platform === "win32" ? "Running automatically · tray ready" : "Running automatically");
+
+    begin(5, "Connecting Codex");
+    const synced = await syncCodex(live.port, options.verbose ? indentedOutput(output) : null);
+    if (synced.status === "skipped") {
+      throw new OnboardStepError("Codex integration changed while setup was running. Retry to converge the saved choice.");
+    }
+    if (!synced.ok) throw new OnboardStepError("Codex configuration could not be verified.", synced.message);
+    codex = routingSummary(synced, provider);
+    complete(5, codex);
+
+    begin(6, "Verifying phone connection");
+    const verified = await waitForVerifiedTunnel(
+      baseUrl,
+      android.mode,
+      readAndroidRemote,
+      sleep,
+      now,
+      deps.tunnelWaitMs ?? DEFAULT_TUNNEL_WAIT_MS,
+      state => {
+        if (options.json || state === "ready" || state === "stopped") return;
+        if (state === "starting") output.log("      Starting secure tunnel…");
+        else if (state === "checking") output.log("      Public address found · verifying…");
+        else if (state === "error") output.log("      Waiting for Cloudflare to recover…");
+      },
+    );
+    const publicUrl = verified.tunnel.runtime.publicUrl!;
+    complete(6, "Public connection verified");
+
+    if (!options.noOpen && dashboardUrl) open(dashboardUrl);
+
+    const result: OnboardResult = {
+      ok: true,
+      code: 0,
+      completedSteps,
+      platform,
+      provider,
+      codex,
+      service,
+      tray,
+      tunnel: { mode: android.mode, status: "verified", publicUrl },
+      dashboardUrl,
+    };
+    if (options.json) {
+      output.log(JSON.stringify(result));
+    } else {
+      output.log("Remodex is ready\n");
+      output.log(`Codex       ${codex}`);
+      output.log("Service     Running automatically");
+      if (platform === "win32") output.log("Tray        Ready");
+      output.log(`Phone link  ${android.mode === "quick" ? "Quick Tunnel" : "Custom domain"} · verified`);
+      output.log(`Dashboard   ${dashboardUrl}\n`);
+      output.log("Next: Scan the QR code in the Remodex Android app.");
+      output.log("Status: rmx status");
+      output.log("Help:   rmx doctor");
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const diagnostic = error instanceof OnboardStepError ? error.diagnostic : undefined;
+    const result = failureResult(
+      completedSteps,
+      platform,
+      provider,
+      codex,
+      service,
+      tray,
+      dashboardUrl,
+      message,
+    );
+    if (options.json) {
+      output.log(JSON.stringify({ ...result, ...(options.verbose && diagnostic ? { diagnostic } : {}) }));
+    } else {
+      output.error("Setup paused\n");
+      output.error(`Completed   ${completedSteps}/${ONBOARD_STEPS} steps`);
+      output.error(`Issue       ${message}`);
+      if (diagnostic) {
+        output.error("Details");
+        for (const line of diagnostic.split(/\r?\n/u)) output.error(`  ${line}`);
+      }
+      output.error("\nRetry: rmx onboard");
+      if (!options.verbose) output.error("More:  rmx onboard --verbose");
+    }
+    return result;
+  }
+}
+
+export async function runOnboardCommand(
+  argv: string[],
+  deps: OnboardDeps = {},
+): Promise<number> {
+  const parsed = parseOnboardArgs(argv);
+  const output = deps.output ?? console;
+  if (!parsed.ok) {
+    output.error(parsed.message);
+    output.error(`Usage: ${ONBOARD_USAGE}`);
+    return 64;
+  }
+  return (await runOnboard(parsed.options, deps)).code;
+}

package/src/cli/system-command.ts

@@ -20,10 +20,7 @@ const USAGE = `Usage:
   rmx system update check [--channel <latest|preview>] [--json]
   rmx system update run [--channel <latest|preview>] [--restart <on|off>] --yes [--json]
   rmx system update status <job-id> [--json]
-  rmx system update auto <on|off|status> [--channel <latest|preview>] [--json]
-  rmx system desktop-update check [--channel <latest|preview>] [--json]
-  rmx system desktop-update run [--channel <latest|preview>] [--json]
-  rmx system desktop-update status [--json]`;
+  rmx system update auto <on|off|status> [--channel <latest|preview>] [--json]`;
 
 async function status(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const args = [...argv];
@@ -132,86 +129,6 @@ async function update(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   printData(result, wantsJson, [`Update started (${channel}).`]);
 }
 
-function desktopUpdateSummary(value: unknown): string[] {
-  if (!value || typeof value !== "object") return [`Desktop update: ${String(value)}`];
-  const record = value as Record<string, unknown>;
-  const state = record.state;
-  const check = record;
-  const lines: string[] = [];
-
-  if (typeof check.currentVersion === "string") {
-    lines.push(`Current version: ${check.currentVersion}`);
-  }
-  if (typeof check.latestVersion === "string") {
-    lines.push(`Latest version: ${check.latestVersion}`);
-  }
-  if (typeof check.phase === "string") {
-    lines.push(`Status: ${check.phase}`);
-  }
-  if (state && typeof state === "object" && !Array.isArray(state)) {
-    const stateRecord = state as Record<string, unknown>;
-    if (typeof stateRecord.phase === "string") lines.push(`Status: ${stateRecord.phase}`);
-    if (typeof stateRecord.latestVersion === "string") {
-      lines.push(`Latest version: ${stateRecord.latestVersion}`);
-    }
-    if (typeof stateRecord.progress === "number") {
-      lines.push(`Progress: ${Math.round(stateRecord.progress)}%`);
-    }
-    if (typeof stateRecord.errorCode === "string") lines.push(`Error: ${stateRecord.errorCode}`);
-  }
-  if (check.updateAvailable === true) lines.push("Update available.");
-  else if (check.updateAvailable === false) lines.push("No desktop update available.");
-  if (lines.length > 0) return lines;
-  return summaryLines(value);
-}
-
-async function desktopUpdate(argv: string[], deps: RuntimeApiDeps): Promise<void> {
-  const args = [...argv];
-  const action = (args.shift() ?? "check").toLowerCase();
-  const wantsJson = takeFlag(args, "--json");
-
-  if (action === "status") {
-    rejectArgs(args, USAGE);
-    const result = await runtimeRequest("/api/desktop-update/status", {}, deps);
-    printData(result, wantsJson, desktopUpdateSummary(result));
-    return;
-  }
-
-  if (action !== "check" && action !== "run") {
-    throw new CliUsageError(`unknown desktop-update action ${action}`, USAGE);
-  }
-
-  const channel = takeOption(args, "--channel") ?? "latest";
-  if (channel !== "latest" && channel !== "preview") {
-    throw new CliUsageError("--channel must be latest or preview", USAGE);
-  }
-  rejectArgs(args, USAGE);
-
-  if (action === "check") {
-    const result = await runtimeRequest(
-      `/api/desktop-update/check?channel=${encodeURIComponent(channel)}`,
-      {},
-      deps,
-    );
-    printData(result, wantsJson, desktopUpdateSummary(result));
-    return;
-  }
-
-  // Headless callers can fetch and verify a native installer, but installation
-  // stays restricted to the exact-origin desktop/Tauri bridge. This mirrors
-  // the management API contract and prevents a shell or remote dashboard from
-  // silently launching a platform installer.
-  const result = await runtimeRequest(
-    "/api/desktop-update/run",
-    {
-      method: "POST",
-      body: JSON.stringify({ channel, install: false }),
-    },
-    deps,
-  );
-  printData(result, wantsJson, [`Desktop update download started (${channel}).`]);
-}
-
 export async function handleSystemCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
   return runCliAction(async () => {
     const [sub = "status", ...rest] = argv;
@@ -225,7 +142,6 @@ export async function handleSystemCommand(argv: string[], deps: RuntimeApiDeps =
       const args = [...rest]; const wantsJson = takeFlag(args, "--json"); rejectArgs(args, USAGE);
       printData(await runtimeRequest("/api/sync", { method: "POST" }, deps), wantsJson);
     } else if (sub === "update") await update(rest, deps);
-    else if (sub === "desktop-update") await desktopUpdate(rest, deps);
     else throw new CliUsageError(`unknown system command ${sub}`, USAGE);
   });
 }