deus-machine 0.3.3

package/dist/cli.js

@@ -0,0 +1,2477 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  default: () => package_default
+});
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "deus-machine",
+      version: "0.3.3",
+      description: "Run Deus IDE from the command line \u2014 headless server or desktop installer",
+      license: "MIT",
+      author: {
+        name: "Deus",
+        email: "hello@deusmachine.ai"
+      },
+      homepage: "https://deusmachine.ai",
+      repository: {
+        type: "git",
+        url: "https://github.com/zvadaadam/deus-machine",
+        directory: "apps/cli"
+      },
+      keywords: [
+        "ide",
+        "ai",
+        "coding",
+        "agent",
+        "claude",
+        "agentic",
+        "desktop",
+        "headless"
+      ],
+      bin: {
+        deus: "./bin/deus.js"
+      },
+      files: [
+        "bin/",
+        "dist/",
+        "bundles/"
+      ],
+      type: "module",
+      engines: {
+        node: ">=20"
+      },
+      scripts: {
+        build: "bunx tsx build.ts"
+      },
+      dependencies: {
+        "@napi-rs/canvas": "^0.1.97",
+        "@openai/codex": "^0.101.0",
+        "@openai/codex-sdk": "^0.101.0",
+        "@sentry/node": "^10.40.0",
+        "agent-browser": "^0.21.4",
+        "better-sqlite3": "^12.4.1",
+        "node-pty": "^1.0.0",
+        ws: "^8.19.0"
+      }
+    };
+  }
+});
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+
+// src/start.ts
+import { spawn, execSync as execSync2 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join3, resolve, dirname } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { homedir as homedir3 } from "node:os";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+
+// ../../shared/runtime.ts
+import path from "node:path";
+var DEUS_APP_ID = "com.deus.app";
+var DEUS_DB_FILENAME = "deus.db";
+var DEUS_PREFERENCES_FILENAME = "preferences.json";
+var RUNTIME_MANIFEST_VERSION = 1;
+var CLI_RUNTIME_DEPENDENCIES = [
+  "@napi-rs/canvas",
+  "@openai/codex",
+  "@openai/codex-sdk",
+  "@sentry/node",
+  "agent-browser",
+  "better-sqlite3",
+  "node-pty",
+  "ws"
+];
+function getPathModule(platform4) {
+  return platform4 === "win32" ? path.win32 : path.posix;
+}
+function resolveDefaultDataDir(options) {
+  const targetPath = getPathModule(options.platform);
+  if (options.platform === "darwin") {
+    return targetPath.join(options.homeDir, "Library", "Application Support", DEUS_APP_ID);
+  }
+  if (options.platform === "win32") {
+    return targetPath.join(
+      options.appData || targetPath.join(options.homeDir, "AppData", "Roaming"),
+      DEUS_APP_ID
+    );
+  }
+  return targetPath.join(
+    options.xdgDataHome || targetPath.join(options.homeDir, ".local", "share"),
+    "deus"
+  );
+}
+function resolveRuntimeStagePaths(projectRoot) {
+  const runtimeRoot = path.join(projectRoot, "dist", "runtime");
+  const commonRoot = path.join(runtimeRoot, "common");
+  const electronRoot = path.join(runtimeRoot, "electron");
+  return {
+    root: runtimeRoot,
+    manifest: path.join(runtimeRoot, "manifest.json"),
+    common: {
+      root: commonRoot,
+      backendBundle: path.join(commonRoot, "server.bundled.cjs"),
+      agentServerBundle: path.join(commonRoot, "agent-server.bundled.cjs")
+    },
+    electron: {
+      root: electronRoot,
+      backendBundle: path.join(electronRoot, "backend", "server.bundled.cjs"),
+      agentServerBundle: path.join(electronRoot, "bin", "index.bundled.cjs")
+    }
+  };
+}
+
+// ../runtime/validate.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var runtimeDir = path2.dirname(fileURLToPath(import.meta.url));
+var defaultProjectRoot = path2.resolve(runtimeDir, "../..");
+var BUILD_RUNTIME_COMMAND = "bun run build:runtime";
+function relativeFromProjectRoot(projectRoot, targetPath) {
+  return path2.relative(projectRoot, targetPath).split(path2.sep).join("/");
+}
+function createBuildRuntimeError(message) {
+  return new Error(`${message}
+Run \`${BUILD_RUNTIME_COMMAND}\` before packaging.`);
+}
+function readManifest(manifestPath) {
+  try {
+    return JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch (error2) {
+    throw createBuildRuntimeError(
+      `Unable to read staged runtime manifest at ${manifestPath}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+}
+function assertExists(filePath, label) {
+  if (!existsSync(filePath)) {
+    throw createBuildRuntimeError(`Missing ${label}: ${filePath}`);
+  }
+}
+function assertNotStale(projectRoot, filePath, label, sourcePath, sourceLabel) {
+  if (statSync(filePath).mtimeMs < statSync(sourcePath).mtimeMs) {
+    throw createBuildRuntimeError(
+      `${label} is stale: ${relativeFromProjectRoot(projectRoot, filePath)} is older than ${relativeFromProjectRoot(projectRoot, sourcePath)} (${sourceLabel})`
+    );
+  }
+}
+function buildExpectedManifest(projectRoot) {
+  const stagePaths = resolveRuntimeStagePaths(projectRoot);
+  return {
+    version: RUNTIME_MANIFEST_VERSION,
+    appId: DEUS_APP_ID,
+    data: {
+      databaseFile: DEUS_DB_FILENAME,
+      preferencesFile: DEUS_PREFERENCES_FILENAME
+    },
+    bundles: {
+      common: {
+        backend: relativeFromProjectRoot(projectRoot, stagePaths.common.backendBundle),
+        agentServer: relativeFromProjectRoot(projectRoot, stagePaths.common.agentServerBundle)
+      },
+      electron: {
+        backend: relativeFromProjectRoot(projectRoot, stagePaths.electron.backendBundle),
+        agentServer: relativeFromProjectRoot(projectRoot, stagePaths.electron.agentServerBundle)
+      }
+    },
+    nodeRuntimeDependencies: CLI_RUNTIME_DEPENDENCIES
+  };
+}
+function validateRuntimeStage(options = {}) {
+  const log = options.log ?? console.log;
+  const projectRoot = options.projectRoot ?? defaultProjectRoot;
+  const stagePaths = resolveRuntimeStagePaths(projectRoot);
+  const sources = {
+    backendBundle: path2.join(projectRoot, "apps", "backend", "dist", "server.bundled.cjs"),
+    agentServerBundle: path2.join(projectRoot, "apps", "agent-server", "dist", "index.bundled.cjs")
+  };
+  assertExists(sources.backendBundle, "runtime source bundle (backend)");
+  assertExists(sources.agentServerBundle, "runtime source bundle (agent-server)");
+  assertExists(stagePaths.manifest, "staged runtime manifest");
+  assertExists(stagePaths.common.backendBundle, "staged common backend bundle");
+  assertExists(stagePaths.common.agentServerBundle, "staged common agent-server bundle");
+  assertExists(stagePaths.electron.backendBundle, "staged electron backend bundle");
+  assertExists(stagePaths.electron.agentServerBundle, "staged electron agent-server bundle");
+  const manifest = readManifest(stagePaths.manifest);
+  const expectedManifest = buildExpectedManifest(projectRoot);
+  if (JSON.stringify(manifest) !== JSON.stringify(expectedManifest)) {
+    throw createBuildRuntimeError(
+      `Staged runtime manifest at ${stagePaths.manifest} does not match the current runtime contract`
+    );
+  }
+  assertNotStale(
+    projectRoot,
+    stagePaths.common.backendBundle,
+    "staged common backend bundle",
+    sources.backendBundle,
+    "backend source bundle"
+  );
+  assertNotStale(
+    projectRoot,
+    stagePaths.electron.backendBundle,
+    "staged electron backend bundle",
+    sources.backendBundle,
+    "backend source bundle"
+  );
+  assertNotStale(
+    projectRoot,
+    stagePaths.common.agentServerBundle,
+    "staged common agent-server bundle",
+    sources.agentServerBundle,
+    "agent-server source bundle"
+  );
+  assertNotStale(
+    projectRoot,
+    stagePaths.electron.agentServerBundle,
+    "staged electron agent-server bundle",
+    sources.agentServerBundle,
+    "agent-server source bundle"
+  );
+  const latestSourceMtime = Math.max(
+    statSync(sources.backendBundle).mtimeMs,
+    statSync(sources.agentServerBundle).mtimeMs
+  );
+  if (statSync(stagePaths.manifest).mtimeMs < latestSourceMtime) {
+    throw createBuildRuntimeError(
+      `Staged runtime manifest is stale: ${relativeFromProjectRoot(projectRoot, stagePaths.manifest)} is older than the source bundles`
+    );
+  }
+  log(
+    `\u2713 Staged runtime ready for packaging (${relativeFromProjectRoot(projectRoot, stagePaths.root)})`
+  );
+  return manifest;
+}
+var entryPath = process.argv[1] ? path2.resolve(process.argv[1]) : null;
+if (entryPath === fileURLToPath(import.meta.url)) {
+  try {
+    validateRuntimeStage();
+  } catch (error2) {
+    console.error("Runtime validation failed:", error2);
+    process.exit(1);
+  }
+}
+
+// src/ui.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var noColor = !!process.env.NO_COLOR || process.argv.includes("--no-color");
+function wrap(code, text) {
+  if (noColor) return text;
+  return `${ESC}${code}m${text}${RESET}`;
+}
+var c = {
+  // Modifiers
+  bold: (t) => wrap("1", t),
+  dim: (t) => wrap("2", t),
+  italic: (t) => wrap("3", t),
+  underline: (t) => wrap("4", t),
+  // Colors
+  red: (t) => wrap("31", t),
+  green: (t) => wrap("32", t),
+  yellow: (t) => wrap("33", t),
+  blue: (t) => wrap("34", t),
+  magenta: (t) => wrap("35", t),
+  cyan: (t) => wrap("36", t),
+  white: (t) => wrap("37", t),
+  gray: (t) => wrap("90", t),
+  // Bright colors
+  brightCyan: (t) => wrap("96", t),
+  brightWhite: (t) => wrap("97", t),
+  // Backgrounds
+  bgCyan: (t) => wrap("46", t),
+  bgBlue: (t) => wrap("44", t),
+  // Combo
+  label: (t) => wrap("1;36", t)
+  // bold cyan
+};
+function rgb(r, g, b, text) {
+  if (noColor) return text;
+  return `\x1B[38;2;${r};${g};${b}m${text}${RESET}`;
+}
+var isUnicode = process.platform !== "win32" || !!process.env.WT_SESSION;
+var sym = {
+  tick: isUnicode ? "\u2713" : "\u221A",
+  cross: isUnicode ? "\u2717" : "\xD7",
+  dot: isUnicode ? "\u25CF" : "*",
+  dash: isUnicode ? "\u2500" : "-",
+  arrow: isUnicode ? "\u2192" : "->",
+  diamond: isUnicode ? "\u25C6" : "*",
+  pointer: isUnicode ? "\u276F" : ">",
+  info: isUnicode ? "\u2139" : "i",
+  warning: isUnicode ? "\u26A0" : "!",
+  bullet: isUnicode ? "\u2022" : "-",
+  // Box drawing
+  tl: isUnicode ? "\u256D" : "+",
+  tr: isUnicode ? "\u256E" : "+",
+  bl: isUnicode ? "\u2570" : "+",
+  br: isUnicode ? "\u256F" : "+",
+  h: isUnicode ? "\u2500" : "-",
+  v: isUnicode ? "\u2502" : "|"
+};
+var LOGO_D = ["\u2588\u2588\u2588\u2588\u2588\u2588\u2557 ", "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557", "\u2588\u2588\u2551  \u2588\u2588\u2551", "\u2588\u2588\u2551  \u2588\u2588\u2551", "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D", "\u255A\u2550\u2550\u2550\u2550\u2550\u255D "];
+var LOGO_E = ["\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D", "\u2588\u2588\u2588\u2588\u2588\u2557  ", "\u2588\u2588\u2554\u2550\u2550\u255D  ", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"];
+var LOGO_U = ["\u2588\u2588\u2557   \u2588\u2588\u2557", "\u2588\u2588\u2551   \u2588\u2588\u2551", "\u2588\u2588\u2551   \u2588\u2588\u2551", "\u2588\u2588\u2551   \u2588\u2588\u2551", "\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D", " \u255A\u2550\u2550\u2550\u2550\u2550\u255D "];
+var LOGO_S = ["\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551", "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"];
+var LETTERS = [LOGO_D, LOGO_E, LOGO_U, LOGO_S];
+var LOGO_BLOCK = [
+  [167, 139, 250],
+  [129, 140, 248],
+  [96, 165, 250],
+  [34, 211, 238]
+];
+var LOGO_INNER = [
+  [100, 83, 150],
+  [77, 84, 149],
+  [58, 99, 150],
+  [20, 127, 143]
+];
+var LOGO_FLOOR = [
+  [60, 50, 90],
+  [46, 50, 89],
+  [35, 59, 90],
+  [12, 76, 86]
+];
+var SHADOW_CHARS = new Set("\u2554\u2550\u2557\u2551\u255A\u255D\u256C\u2560\u2563\u2566\u2569\u2553\u2556\u2559\u255C\u2552\u2555\u2558\u255B\u250C\u2510\u2514\u2518\u252C\u2534\u251C\u2524\u253C\u2500\u2502");
+function colorLogo(text, block, shadow) {
+  let result = "";
+  let buf = "";
+  let cur = null;
+  function flush() {
+    if (!buf) return;
+    if (cur === "b") result += rgb(block[0], block[1], block[2], buf);
+    else if (cur === "s") result += rgb(shadow[0], shadow[1], shadow[2], buf);
+    else result += buf;
+    buf = "";
+  }
+  for (const ch of text) {
+    const t = ch === " " ? " " : SHADOW_CHARS.has(ch) ? "s" : "b";
+    if (t !== cur) {
+      flush();
+      cur = t;
+    }
+    buf += ch;
+  }
+  flush();
+  return result;
+}
+var LOGO_ASCII = [
+  "  DDDD   EEEEE  U   U  SSSS ",
+  "  D   D  E      U   U  S    ",
+  "  D   D  EEE    U   U   SS  ",
+  "  D   D  E      U   U     S ",
+  "  DDDD   EEEEE  UUUUU  SSSS "
+];
+function renderLogoFrame(letterCount) {
+  const lines = [];
+  for (let row = 0; row < 6; row++) {
+    const shadow = row === 5 ? LOGO_FLOOR : LOGO_INNER;
+    let line = "  ";
+    for (let l = 0; l < letterCount; l++) {
+      line += colorLogo(LETTERS[l][row], LOGO_BLOCK[l], shadow[l]);
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function banner(version) {
+  console.log("");
+  if (isUnicode && !noColor) {
+    for (const line of renderLogoFrame(4)) {
+      console.log(line);
+    }
+  } else {
+    for (const line of LOGO_ASCII) {
+      console.log(c.cyan(line));
+    }
+  }
+  console.log("");
+  const tag = c.dim("  Agentic Engineering");
+  const ver = version ? `  ${c.dim("v" + version)}` : "";
+  console.log(tag + ver);
+  console.log("");
+}
+async function animatedBanner(version) {
+  if (!isUnicode || noColor || !process.stdout.isTTY) {
+    banner(version);
+    return;
+  }
+  const out = process.stdout;
+  const LOGO_ROWS = 6;
+  const FRAME_DELAY = 80;
+  console.log("");
+  for (let i = 0; i < LOGO_ROWS; i++) {
+    out.write("\n");
+  }
+  for (let letterCount = 1; letterCount <= 4; letterCount++) {
+    out.write(`${ESC}${LOGO_ROWS}A`);
+    const frame = renderLogoFrame(letterCount);
+    for (const line of frame) {
+      out.write(`${ESC}2K${line}
+`);
+    }
+    if (letterCount < 4) {
+      await sleep(FRAME_DELAY);
+    }
+  }
+  await sleep(100);
+  console.log("");
+  const tag = c.dim("  Agentic Engineering");
+  const ver = version ? `  ${c.dim("v" + version)}` : "";
+  console.log(tag + ver);
+  console.log("");
+}
+var SPINNER_FRAMES = isUnicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+var SPINNER_INTERVAL = 80;
+function spinner(text) {
+  const stream = process.stderr;
+  if (!stream.isTTY) {
+    const write = (symbol, finalText) => stream.write(`  ${symbol} ${finalText}
+`);
+    return {
+      update() {
+      },
+      succeed(t) {
+        write(c.green(sym.tick), t ?? text);
+      },
+      fail(t) {
+        write(c.red(sym.cross), t ?? text);
+      },
+      warn(t) {
+        write(c.yellow(sym.warning), t ?? text);
+      },
+      info(t) {
+        write(c.blue(sym.info), t ?? text);
+      },
+      stop() {
+      }
+    };
+  }
+  let frameIdx = 0;
+  let currentText = text;
+  let stopped = false;
+  function render() {
+    if (stopped) return;
+    const frame = c.cyan(SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length]);
+    stream.write(`\r${ESC}2K  ${frame} ${currentText}`);
+    frameIdx++;
+  }
+  const interval = setInterval(render, SPINNER_INTERVAL);
+  render();
+  function stop(symbol, finalText) {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(interval);
+    stream.write(`\r${ESC}2K  ${symbol} ${finalText}
+`);
+  }
+  return {
+    update(t) {
+      currentText = t;
+    },
+    succeed(t) {
+      stop(c.green(sym.tick), t ?? currentText);
+    },
+    fail(t) {
+      stop(c.red(sym.cross), t ?? currentText);
+    },
+    warn(t) {
+      stop(c.yellow(sym.warning), t ?? currentText);
+    },
+    info(t) {
+      stop(c.blue(sym.info), t ?? currentText);
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(interval);
+      stream.write(`\r${ESC}2K`);
+    }
+  };
+}
+function box(lines, opts) {
+  const { padding = 1, borderColor = c.dim, width } = opts ?? {};
+  const pad = " ".repeat(padding);
+  const stripped = lines.map(stripAnsi);
+  const contentWidth = width ?? Math.max(...stripped.map((l) => l.length));
+  const innerWidth = contentWidth + padding * 2;
+  const top = borderColor(`  ${sym.tl}${sym.h.repeat(innerWidth)}${sym.tr}`);
+  const bot = borderColor(`  ${sym.bl}${sym.h.repeat(innerWidth)}${sym.br}`);
+  const empty = borderColor(`  ${sym.v}`) + " ".repeat(innerWidth) + borderColor(sym.v);
+  console.log(top);
+  console.log(empty);
+  for (let i = 0; i < lines.length; i++) {
+    const visible = stripped[i].length;
+    const rightPad = " ".repeat(Math.max(0, contentWidth - visible));
+    console.log(borderColor(`  ${sym.v}`) + pad + lines[i] + rightPad + pad + borderColor(sym.v));
+  }
+  console.log(empty);
+  console.log(bot);
+}
+function divider(label, width = 44) {
+  if (label) {
+    const lineLen = Math.max(0, width - label.length - 3);
+    console.log(c.dim(`  ${sym.h.repeat(2)} ${label} ${sym.h.repeat(lineLen)}`));
+  } else {
+    console.log(c.dim(`  ${sym.h.repeat(width)}`));
+  }
+}
+function kv(label, value, labelWidth = 12) {
+  const paddedLabel = label.padEnd(labelWidth);
+  console.log(`  ${c.dim(paddedLabel)} ${value}`);
+}
+function success(text) {
+  console.log(`  ${c.green(sym.tick)} ${text}`);
+}
+function error(text) {
+  console.log(`  ${c.red(sym.cross)} ${text}`);
+}
+function warn(text) {
+  console.log(`  ${c.yellow(sym.warning)} ${text}`);
+}
+function info(text) {
+  console.log(`  ${c.blue(sym.info)} ${text}`);
+}
+function hint(text) {
+  console.log(c.dim(`  ${text}`));
+}
+function blank() {
+  console.log("");
+}
+function gradientText(text, from, to) {
+  if (noColor) return text;
+  let result = "";
+  for (let i = 0; i < text.length; i++) {
+    const t = text.length > 1 ? i / (text.length - 1) : 0;
+    const r = Math.round(from[0] + (to[0] - from[0]) * t);
+    const g = Math.round(from[1] + (to[1] - from[1]) * t);
+    const b = Math.round(from[2] + (to[2] - from[2]) * t);
+    result += rgb(r, g, b, text[i]);
+  }
+  return result;
+}
+function statusLine(getText, intervalMs = 1e3) {
+  const stream = process.stderr;
+  if (!stream.isTTY) {
+    stream.write(`  ${c.dim(sym.dot)} ${getText()}
+`);
+    return { stop() {
+    } };
+  }
+  let stopped = false;
+  let dotCount = 0;
+  const dots = ["   ", ".  ", ".. ", "..."];
+  function render() {
+    if (stopped) return;
+    const dot = c.dim(dots[dotCount % dots.length]);
+    stream.write(`\r${ESC}2K  ${c.dim(sym.dot)} ${getText()}${dot}`);
+    dotCount++;
+  }
+  const interval = setInterval(render, intervalMs);
+  render();
+  return {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(interval);
+      stream.write(`\r${ESC}2K`);
+    }
+  };
+}
+var BAR_WIDTH = 30;
+var BAR_FILLED = isUnicode ? "\u2588" : "#";
+var BAR_EMPTY = isUnicode ? "\u2591" : ".";
+function progressBar(current, total, label) {
+  if (!process.stderr.isTTY) return;
+  const pct = Math.min(1, current / total);
+  const filled = Math.round(pct * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const bar = c.cyan(BAR_FILLED.repeat(filled)) + c.dim(BAR_EMPTY.repeat(empty));
+  const pctStr = `${Math.round(pct * 100)}%`.padStart(4);
+  const extra = label ? ` ${c.dim(label)}` : "";
+  process.stderr.write(`\r${ESC}2K  ${bar} ${pctStr}${extra}`);
+}
+function progressBarDone(text) {
+  if (process.stderr.isTTY) {
+    process.stderr.write(`\r${ESC}2K`);
+  }
+  success(text);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/config.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  existsSync as existsSync2,
+  unlinkSync,
+  renameSync,
+  mkdirSync,
+  chmodSync
+} from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { randomBytes } from "node:crypto";
+var DEFAULT_CONFIG = {
+  onboarding_completed: false,
+  auth_method: null,
+  relay_enabled: true
+};
+function getConfigDir() {
+  const os = platform();
+  if (os === "darwin") {
+    return join(homedir(), ".config", "deus");
+  }
+  if (os === "win32") {
+    return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "deus");
+  }
+  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "deus");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getServerInfoPath() {
+  return join(getConfigDir(), "server.json");
+}
+function loadConfig() {
+  const path3 = getConfigPath();
+  if (!existsSync2(path3)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = readFileSync2(path3, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const dir = getConfigDir();
+  mkdirSync(dir, { recursive: true });
+  const path3 = getConfigPath();
+  const tmp = path3 + ".tmp." + randomBytes(4).toString("hex");
+  try {
+    writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    chmodSync(tmp, 384);
+    renameSync(tmp, path3);
+  } catch {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw new Error(`Failed to save config to ${path3}`);
+  }
+}
+function hasCompletedOnboarding() {
+  return loadConfig().onboarding_completed;
+}
+function writeServerInfo(info2) {
+  const dir = getConfigDir();
+  mkdirSync(dir, { recursive: true });
+  const path3 = getServerInfoPath();
+  writeFileSync(path3, JSON.stringify(info2, null, 2) + "\n", "utf-8");
+  chmodSync(path3, 384);
+}
+function readServerInfo() {
+  const path3 = getServerInfoPath();
+  if (!existsSync2(path3)) return null;
+  try {
+    const raw = readFileSync2(path3, "utf-8");
+    const info2 = JSON.parse(raw);
+    try {
+      process.kill(info2.pid, 0);
+    } catch {
+      clearServerInfo();
+      return null;
+    }
+    return info2;
+  } catch {
+    return null;
+  }
+}
+function clearServerInfo() {
+  const path3 = getServerInfoPath();
+  try {
+    unlinkSync(path3);
+  } catch {
+  }
+}
+
+// src/login.ts
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2, platform as platform2 } from "node:os";
+
+// src/prompt.ts
+var ESC2 = "\x1B[";
+async function select(opts) {
+  const { message, options } = opts;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    throw new Error(
+      "Interactive prompts require a TTY. Run in a terminal or set ANTHROPIC_API_KEY env var."
+    );
+  }
+  const stream = process.stderr;
+  let selected = 0;
+  stream.write(`  ${message}
+`);
+  function render() {
+    if (selected >= 0) {
+      stream.write(`${ESC2}${options.length}A`);
+    }
+    for (let i = 0; i < options.length; i++) {
+      const opt = options[i];
+      const isActive = i === selected;
+      const pointer = isActive ? c.cyan(sym.pointer) : " ";
+      const label = isActive ? c.cyan(opt.label) : c.dim(opt.label);
+      const hintText = opt.hint ? `  ${c.dim(opt.hint)}` : "";
+      stream.write(`${ESC2}2K  ${pointer} ${label}${hintText}
+`);
+    }
+  }
+  for (let i = 0; i < options.length; i++) stream.write("\n");
+  render();
+  return new Promise((resolve2) => {
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    function cleanup() {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+    }
+    function onData(buf) {
+      const key = buf.toString();
+      if (key === "") {
+        cleanup();
+        stream.write("\n");
+        process.exit(130);
+      }
+      if (key === "\x1B[A" || key === "k") {
+        selected = (selected - 1 + options.length) % options.length;
+        render();
+        return;
+      }
+      if (key === "\x1B[B" || key === "j") {
+        selected = (selected + 1) % options.length;
+        render();
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        stream.write(`${ESC2}${options.length}A`);
+        for (let i = 0; i < options.length; i++) {
+          stream.write(`${ESC2}2K
+`);
+        }
+        stream.write(`${ESC2}${options.length}A`);
+        stream.write(`${ESC2}2K  ${c.green(sym.tick)} ${options[selected].label}
+`);
+        resolve2(options[selected].value);
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+async function input(opts) {
+  const { message, placeholder, mask } = opts;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    throw new Error(
+      "Interactive prompts require a TTY. Run in a terminal or set ANTHROPIC_API_KEY env var."
+    );
+  }
+  const stream = process.stderr;
+  let value = "";
+  function renderValue() {
+    if (!value) {
+      return placeholder ? c.dim(placeholder) : "";
+    }
+    if (mask) {
+      const visible = value.slice(0, 7);
+      const hidden = "\u2022".repeat(Math.max(0, value.length - 7));
+      return visible + c.dim(hidden);
+    }
+    return value;
+  }
+  stream.write(`  ${message}
+`);
+  stream.write(`${ESC2}2K  ${renderValue()}`);
+  return new Promise((resolve2) => {
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    function cleanup() {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+    }
+    function onData(buf) {
+      const key = buf.toString();
+      if (key === "") {
+        cleanup();
+        stream.write("\n");
+        process.exit(130);
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        stream.write(`\r${ESC2}2K  ${c.green(sym.tick)} ${mask ? renderValue() : value}
+`);
+        resolve2(value);
+        return;
+      }
+      if (key === "\x7F" || key === "\b") {
+        value = value.slice(0, -1);
+        stream.write(`\r${ESC2}2K  ${renderValue()}`);
+        return;
+      }
+      if (key.charCodeAt(0) < 32) return;
+      value += key;
+      stream.write(`\r${ESC2}2K  ${renderValue()}`);
+    }
+    stdin.on("data", onData);
+  });
+}
+async function confirm(opts) {
+  const { message, default: defaultValue = true } = opts;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    throw new Error(
+      "Interactive prompts require a TTY. Run in a terminal or set ANTHROPIC_API_KEY env var."
+    );
+  }
+  const stream = process.stderr;
+  const hint2 = defaultValue ? `[${c.bold("Y")}/n]` : `[y/${c.bold("N")}]`;
+  stream.write(`  ${message} ${hint2} `);
+  return new Promise((resolve2) => {
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    function cleanup() {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+    }
+    function onData(buf) {
+      const key = buf.toString().toLowerCase();
+      if (key === "") {
+        cleanup();
+        stream.write("\n");
+        process.exit(130);
+      }
+      if (key === "y") {
+        cleanup();
+        stream.write(`\r${ESC2}2K  ${c.green(sym.tick)} ${message} ${c.dim("Yes")}
+`);
+        resolve2(true);
+        return;
+      }
+      if (key === "n") {
+        cleanup();
+        stream.write(`\r${ESC2}2K  ${c.dim(sym.dash)} ${message} ${c.dim("No")}
+`);
+        resolve2(false);
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        const result = defaultValue;
+        const icon = result ? c.green(sym.tick) : c.dim(sym.dash);
+        const text = result ? c.dim("Yes") : c.dim("No");
+        stream.write(`\r${ESC2}2K  ${icon} ${message} ${text}
+`);
+        resolve2(result);
+        return;
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+
+// src/login.ts
+function getClaudeCliCandidates() {
+  const candidates = [];
+  if (process.env.CLAUDE_CLI_PATH) {
+    candidates.push(process.env.CLAUDE_CLI_PATH);
+  }
+  const os = platform2();
+  if (os === "darwin") {
+    candidates.push(
+      "/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+      "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+      join2(homedir2(), ".npm/lib/node_modules/@anthropic-ai/claude-code/cli.js")
+    );
+  } else if (os === "linux") {
+    candidates.push(
+      "/usr/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+      "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+      join2(homedir2(), ".npm/lib/node_modules/@anthropic-ai/claude-code/cli.js")
+    );
+  }
+  return candidates;
+}
+function detectClaudeCli() {
+  for (const candidate of getClaudeCliCandidates()) {
+    if (existsSync3(candidate)) {
+      try {
+        const version = execSync(`node "${candidate}" --version`, {
+          encoding: "utf-8",
+          timeout: 5e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        return { installed: true, path: candidate, version };
+      } catch {
+      }
+    }
+  }
+  try {
+    const claudePath = platform2() === "win32" ? execSync("where claude", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split(/\r?\n/)[0] : execSync(`${process.env.SHELL || "/bin/sh"} -lc "command -v claude"`, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (claudePath) {
+      try {
+        const version = execSync(`"${claudePath}" --version`, {
+          encoding: "utf-8",
+          timeout: 5e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        return { installed: true, path: claudePath, version };
+      } catch {
+        return { installed: true, path: claudePath };
+      }
+    }
+  } catch {
+  }
+  return { installed: false };
+}
+function isClaudeAuthenticated() {
+  const credPaths = [
+    join2(homedir2(), ".claude", ".credentials.json"),
+    join2(homedir2(), ".claude", "credentials.json")
+  ];
+  for (const p of credPaths) {
+    if (existsSync3(p)) return true;
+  }
+  return false;
+}
+function persistAuth(result) {
+  const config = loadConfig();
+  config.auth_method = result.method;
+  config.anthropic_api_key = result.method === "api_key" ? result.apiKey : void 0;
+  saveConfig(config);
+}
+async function runAuthSetup(opts) {
+  const config = loadConfig();
+  if (!opts?.force && config.auth_method) {
+    return {
+      method: config.auth_method,
+      apiKey: config.anthropic_api_key
+    };
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    success("ANTHROPIC_API_KEY detected in environment");
+    blank();
+    const result = { method: "env" };
+    persistAuth(result);
+    return result;
+  }
+  const cli = detectClaudeCli();
+  if (cli.installed && isClaudeAuthenticated()) {
+    success(`Claude Code CLI found${cli.version ? ` (${c.dim(cli.version)})` : ""}`);
+    success("Authenticated");
+    blank();
+    hint("Ready to go! No additional setup needed.");
+    blank();
+    const result = { method: "claude_cli" };
+    persistAuth(result);
+    return result;
+  }
+  if (cli.installed) {
+    success(`Claude Code CLI found${cli.version ? ` (${c.dim(cli.version)})` : ""}`);
+    warn("Not authenticated");
+    blank();
+    const choice2 = await select({
+      message: "How would you like to authenticate?",
+      options: [
+        { label: "Run claude login", value: "login", hint: "opens browser to sign in" },
+        { label: "Enter API key manually", value: "api_key" },
+        { label: "Skip for now", value: "skip" }
+      ]
+    });
+    if (choice2 === "login") {
+      return await runClaudeLogin(cli.path);
+    }
+    if (choice2 === "api_key") {
+      return await promptForApiKey();
+    }
+    return skipAuth();
+  }
+  error("Claude Code CLI not found");
+  blank();
+  hint("Deus uses Claude Code to power AI agents.");
+  blank();
+  const choice = await select({
+    message: "How would you like to set it up?",
+    options: [
+      {
+        label: "Install Claude Code",
+        value: "install",
+        hint: "npm install -g @anthropic-ai/claude-code"
+      },
+      { label: "Enter API key manually", value: "api_key" },
+      { label: "Skip for now", value: "skip" }
+    ]
+  });
+  if (choice === "install") {
+    return await installAndLogin();
+  }
+  if (choice === "api_key") {
+    return await promptForApiKey();
+  }
+  return skipAuth();
+}
+async function runClaudeLogin(cliPath) {
+  blank();
+  hint("Opening browser for authentication...");
+  blank();
+  const result = spawnSync(cliPath, ["login"], {
+    stdio: "inherit",
+    timeout: 12e4
+  });
+  if (result.status === 0 && isClaudeAuthenticated()) {
+    blank();
+    success("Authenticated successfully!");
+    blank();
+    persistAuth({ method: "claude_cli" });
+    return { method: "claude_cli" };
+  }
+  blank();
+  warn("Authentication may not have completed.");
+  hint(`You can try again later with ${c.cyan("deus login")}`);
+  blank();
+  return skipAuth();
+}
+async function installAndLogin() {
+  blank();
+  const s = spinner("Installing Claude Code CLI...");
+  const result = spawnSync("npm", ["install", "-g", "@anthropic-ai/claude-code"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 12e4
+  });
+  if (result.status !== 0) {
+    s.fail("Installation failed");
+    blank();
+    hint("Try installing manually:");
+    console.log(`    ${c.cyan("npm install -g @anthropic-ai/claude-code")}`);
+    blank();
+    return skipAuth();
+  }
+  s.succeed("Claude Code CLI installed");
+  const cli = detectClaudeCli();
+  if (cli.installed && cli.path) {
+    return await runClaudeLogin(cli.path);
+  }
+  blank();
+  warn("CLI installed but could not be found in PATH.");
+  hint("Try opening a new terminal and running:");
+  console.log(`    ${c.cyan("claude login")}`);
+  blank();
+  return skipAuth();
+}
+async function promptForApiKey() {
+  blank();
+  hint(`Get your key from ${c.cyan(c.underline("console.anthropic.com"))}`);
+  blank();
+  const key = await input({
+    message: "Enter your Anthropic API key:",
+    mask: true
+  });
+  if (!key || key.trim().length < 10) {
+    blank();
+    warn("Invalid API key.");
+    return skipAuth();
+  }
+  const trimmed = key.trim();
+  if (!trimmed.startsWith("sk-ant-")) {
+    blank();
+    warn("Key doesn't look like an Anthropic API key (should start with sk-ant-)");
+    hint("Saving anyway \u2014 you can change it later.");
+  }
+  blank();
+  success("API key saved");
+  blank();
+  persistAuth({ method: "api_key", apiKey: trimmed });
+  return { method: "api_key", apiKey: trimmed };
+}
+function skipAuth() {
+  persistAuth({ method: "skipped" });
+  hint(`You can configure this later with ${c.cyan("deus login")}`);
+  blank();
+  return { method: "skipped" };
+}
+
+// src/onboarding.ts
+async function runOnboarding() {
+  if (hasCompletedOnboarding()) {
+    const config2 = loadConfig();
+    return {
+      auth: {
+        method: config2.auth_method || "skipped",
+        apiKey: config2.anthropic_api_key
+      },
+      relayEnabled: config2.relay_enabled
+    };
+  }
+  hint("Welcome to Deus! Let's get you set up.");
+  blank();
+  divider("Step 1 of 2 \u2014 AI Agent");
+  blank();
+  const auth = await runAuthSetup({ force: true });
+  divider("Step 2 of 2 \u2014 Remote Access");
+  blank();
+  hint("Access Deus from your phone or another");
+  hint(`computer via ${c.cyan(c.underline("app.deusmachine.ai"))}`);
+  blank();
+  const relayEnabled = await confirm({
+    message: "Enable remote access?",
+    default: true
+  });
+  if (relayEnabled) {
+    success("Remote access enabled");
+  } else {
+    hint("Remote access disabled. You can enable it later in Settings.");
+  }
+  blank();
+  const config = loadConfig();
+  config.onboarding_completed = true;
+  config.relay_enabled = relayEnabled;
+  config.installed_at = (/* @__PURE__ */ new Date()).toISOString();
+  saveConfig(config);
+  divider("All set!");
+  blank();
+  return { auth, relayEnabled };
+}
+
+// src/qr.ts
+var EXP = new Uint8Array(256);
+var LOG = new Uint8Array(256);
+(() => {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x = x << 1 ^ (x & 128 ? 285 : 0);
+  }
+  EXP[255] = EXP[0];
+})();
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return EXP[(LOG[a] + LOG[b]) % 255];
+}
+function rsGeneratorPoly(n) {
+  let g = new Uint8Array([1]);
+  for (let i = 0; i < n; i++) {
+    const next = new Uint8Array(g.length + 1);
+    for (let j = 0; j < g.length; j++) {
+      next[j] ^= g[j];
+      next[j + 1] ^= gfMul(g[j], EXP[i]);
+    }
+    g = next;
+  }
+  return g;
+}
+function rsEncode(data, ecCount) {
+  const gen = rsGeneratorPoly(ecCount);
+  const result = new Uint8Array(data.length + ecCount);
+  result.set(data);
+  for (let i = 0; i < data.length; i++) {
+    const coef = result[i];
+    if (coef !== 0) {
+      for (let j = 0; j < gen.length; j++) {
+        result[i + j] ^= gfMul(gen[j], coef);
+      }
+    }
+  }
+  return result.slice(data.length);
+}
+var VERSION_INFO = [
+  [0, 0, 0],
+  // v0 placeholder
+  [26, 7, 1],
+  // v1: 26 total, 7 EC, 1 block → 19 data
+  [44, 10, 1],
+  // v2: 44 total, 10 EC → 34 data
+  [70, 15, 1],
+  // v3: 70 total, 15 EC → 55 data
+  [100, 20, 1],
+  // v4: 100 total, 20 EC → 80 data
+  [134, 26, 1]
+  // v5: 134 total, 26 EC → 108 data
+];
+var ALIGNMENT_POS = [
+  [],
+  // v0
+  [],
+  // v1
+  [6, 18],
+  // v2
+  [6, 22],
+  // v3
+  [6, 26],
+  // v4
+  [6, 30]
+  // v5
+];
+function getVersion(dataLen) {
+  for (let v = 1; v <= 5; v++) {
+    const [total, ec] = VERSION_INFO[v];
+    const dataCapacity = total - ec;
+    const overhead = v <= 9 ? 2 : 3;
+    if (dataLen + overhead <= dataCapacity) return v;
+  }
+  throw new Error("Data too long for QR version 1-5");
+}
+function encodeData(data, version) {
+  const [totalCW, ecCW] = VERSION_INFO[version];
+  const dataCW = totalCW - ecCW;
+  const buf = new Uint8Array(dataCW);
+  let bitPos = 0;
+  function writeBits(val, count) {
+    for (let i = count - 1; i >= 0; i--) {
+      if (val & 1 << i) {
+        buf[bitPos >> 3] |= 128 >> (bitPos & 7);
+      }
+      bitPos++;
+    }
+  }
+  writeBits(4, 4);
+  writeBits(data.length, 8);
+  for (let i = 0; i < data.length; i++) {
+    writeBits(data.charCodeAt(i) & 255, 8);
+  }
+  writeBits(0, Math.min(4, dataCW * 8 - bitPos));
+  bitPos = Math.ceil(bitPos / 8) * 8;
+  let padByte = 0;
+  const padPatterns = [236, 17];
+  while (bitPos < dataCW * 8) {
+    writeBits(padPatterns[padByte % 2], 8);
+    padByte++;
+  }
+  return buf;
+}
+function createMatrix(version) {
+  const size = 17 + version * 4;
+  const matrix = [];
+  for (let i = 0; i < size; i++) {
+    matrix.push(new Array(size).fill(-1));
+  }
+  return { matrix, size };
+}
+function addFinderPattern(matrix, row, col) {
+  for (let r = -1; r <= 7; r++) {
+    for (let c2 = -1; c2 <= 7; c2++) {
+      const mr = row + r;
+      const mc = col + c2;
+      if (mr < 0 || mr >= matrix.length || mc < 0 || mc >= matrix.length) continue;
+      if (r === -1 || r === 7 || c2 === -1 || c2 === 7) {
+        matrix[mr][mc] = 0;
+      } else if (r === 0 || r === 6 || c2 === 0 || c2 === 6) {
+        matrix[mr][mc] = 1;
+      } else if (r >= 2 && r <= 4 && c2 >= 2 && c2 <= 4) {
+        matrix[mr][mc] = 1;
+      } else {
+        matrix[mr][mc] = 0;
+      }
+    }
+  }
+}
+function addAlignmentPattern(matrix, row, col) {
+  for (let r = -2; r <= 2; r++) {
+    for (let c2 = -2; c2 <= 2; c2++) {
+      const mr = row + r;
+      const mc = col + c2;
+      if (matrix[mr][mc] !== -1) continue;
+      if (Math.abs(r) === 2 || Math.abs(c2) === 2) {
+        matrix[mr][mc] = 1;
+      } else if (r === 0 && c2 === 0) {
+        matrix[mr][mc] = 1;
+      } else {
+        matrix[mr][mc] = 0;
+      }
+    }
+  }
+}
+function addTimingPatterns(matrix, size) {
+  for (let i = 8; i < size - 8; i++) {
+    if (matrix[6][i] === -1) matrix[6][i] = i % 2 === 0 ? 1 : 0;
+    if (matrix[i][6] === -1) matrix[i][6] = i % 2 === 0 ? 1 : 0;
+  }
+}
+function reserveFormatArea(matrix, size) {
+  for (let i = 0; i <= 8; i++) {
+    if (matrix[8][i] === -1) matrix[8][i] = 0;
+    if (matrix[i][8] === -1) matrix[i][8] = 0;
+  }
+  for (let i = 0; i <= 7; i++) {
+    if (matrix[8][size - 1 - i] === -1) matrix[8][size - 1 - i] = 0;
+  }
+  for (let i = 0; i <= 7; i++) {
+    if (matrix[size - 1 - i][8] === -1) matrix[size - 1 - i][8] = 0;
+  }
+  matrix[size - 8][8] = 1;
+}
+function placeData(matrix, size, dataBits) {
+  let bitIdx = 0;
+  let upward = true;
+  for (let col = size - 1; col >= 1; col -= 2) {
+    if (col === 6) col = 5;
+    const rows = upward ? Array.from({ length: size }, (_, i) => size - 1 - i) : Array.from({ length: size }, (_, i) => i);
+    for (const row of rows) {
+      for (const dc of [0, -1]) {
+        const c2 = col + dc;
+        if (c2 < 0 || matrix[row][c2] !== -1) continue;
+        matrix[row][c2] = bitIdx < dataBits.length ? dataBits[bitIdx++] : 0;
+      }
+    }
+    upward = !upward;
+  }
+}
+var MASKS = [
+  (r, c2) => (r + c2) % 2 === 0,
+  (r) => r % 2 === 0,
+  (_, c2) => c2 % 3 === 0,
+  (r, c2) => (r + c2) % 3 === 0,
+  (r, c2) => (Math.floor(r / 2) + Math.floor(c2 / 3)) % 2 === 0,
+  (r, c2) => r * c2 % 2 + r * c2 % 3 === 0,
+  (r, c2) => (r * c2 % 2 + r * c2 % 3) % 2 === 0,
+  (r, c2) => ((r + c2) % 2 + r * c2 % 3) % 2 === 0
+];
+function applyMask(matrix, reserved, size, maskIdx) {
+  const masked = matrix.map((r) => [...r]);
+  const fn = MASKS[maskIdx];
+  for (let r = 0; r < size; r++) {
+    for (let c2 = 0; c2 < size; c2++) {
+      if (!reserved[r][c2] && fn(r, c2)) {
+        masked[r][c2] ^= 1;
+      }
+    }
+  }
+  return masked;
+}
+function scoreMask(matrix, size) {
+  let score = 0;
+  for (let r = 0; r < size; r++) {
+    let count = 1;
+    for (let c2 = 1; c2 < size; c2++) {
+      if (matrix[r][c2] === matrix[r][c2 - 1]) {
+        count++;
+        if (count === 5) score += 3;
+        else if (count > 5) score += 1;
+      } else {
+        count = 1;
+      }
+    }
+  }
+  for (let c2 = 0; c2 < size; c2++) {
+    let count = 1;
+    for (let r = 1; r < size; r++) {
+      if (matrix[r][c2] === matrix[r - 1][c2]) {
+        count++;
+        if (count === 5) score += 3;
+        else if (count > 5) score += 1;
+      } else {
+        count = 1;
+      }
+    }
+  }
+  for (let r = 0; r < size; r++) {
+    for (let c2 = 0; c2 <= size - 7; c2++) {
+      if (matrix[r][c2] === 1 && matrix[r][c2 + 1] === 0 && matrix[r][c2 + 2] === 1 && matrix[r][c2 + 3] === 1 && matrix[r][c2 + 4] === 1 && matrix[r][c2 + 5] === 0 && matrix[r][c2 + 6] === 1) {
+        score += 40;
+      }
+    }
+  }
+  return score;
+}
+var FORMAT_STRINGS = [30660, 29427, 32170, 30877, 26159, 25368, 27713, 26998];
+function placeFormatInfo(matrix, size, maskIdx) {
+  const bits = FORMAT_STRINGS[maskIdx];
+  const positions1 = [
+    [8, 0],
+    [8, 1],
+    [8, 2],
+    [8, 3],
+    [8, 4],
+    [8, 5],
+    [8, 7],
+    [8, 8],
+    [7, 8],
+    [5, 8],
+    [4, 8],
+    [3, 8],
+    [2, 8],
+    [1, 8],
+    [0, 8]
+  ];
+  const positions2 = [
+    [size - 1, 8],
+    [size - 2, 8],
+    [size - 3, 8],
+    [size - 4, 8],
+    [size - 5, 8],
+    [size - 6, 8],
+    [size - 7, 8],
+    [8, size - 8],
+    [8, size - 7],
+    [8, size - 6],
+    [8, size - 5],
+    [8, size - 4],
+    [8, size - 3],
+    [8, size - 2],
+    [8, size - 1]
+  ];
+  for (let i = 0; i < 15; i++) {
+    const bit = bits >> i & 1;
+    const [r1, c1] = positions1[i];
+    matrix[r1][c1] = bit;
+    const [r2, c2] = positions2[i];
+    matrix[r2][c2] = bit;
+  }
+}
+function generateQR(data) {
+  const version = getVersion(data.length);
+  const [totalCW, ecCW] = VERSION_INFO[version];
+  const size = 17 + version * 4;
+  const dataCodewords = encodeData(data, version);
+  const ecCodewords = rsEncode(dataCodewords, ecCW);
+  const allCodewords = new Uint8Array(totalCW);
+  allCodewords.set(dataCodewords);
+  allCodewords.set(ecCodewords, dataCodewords.length);
+  const dataBits = [];
+  for (const byte of allCodewords) {
+    for (let bit = 7; bit >= 0; bit--) {
+      dataBits.push(byte >> bit & 1);
+    }
+  }
+  const { matrix } = createMatrix(version);
+  addFinderPattern(matrix, 0, 0);
+  addFinderPattern(matrix, 0, size - 7);
+  addFinderPattern(matrix, size - 7, 0);
+  addTimingPatterns(matrix, size);
+  const alignPos = ALIGNMENT_POS[version];
+  if (alignPos.length > 0) {
+    for (const r of alignPos) {
+      for (const c2 of alignPos) {
+        if (r <= 8 && c2 <= 8) continue;
+        if (r <= 8 && c2 >= size - 8) continue;
+        if (r >= size - 8 && c2 <= 8) continue;
+        addAlignmentPattern(matrix, r, c2);
+      }
+    }
+  }
+  reserveFormatArea(matrix, size);
+  const reserved = matrix.map((r) => r.map((v) => v !== -1));
+  placeData(matrix, size, dataBits);
+  let bestMask = 0;
+  let bestScore = Infinity;
+  for (let m = 0; m < 8; m++) {
+    const masked = applyMask(matrix, reserved, size, m);
+    placeFormatInfo(masked, size, m);
+    const score = scoreMask(masked, size);
+    if (score < bestScore) {
+      bestScore = score;
+      bestMask = m;
+    }
+  }
+  const final = applyMask(matrix, reserved, size, bestMask);
+  placeFormatInfo(final, size, bestMask);
+  const QUIET = 4;
+  const qSize = size + QUIET * 2;
+  const lines = [];
+  for (let r = 0; r < qSize; r += 2) {
+    let line = "";
+    for (let c2 = 0; c2 < qSize; c2++) {
+      const topR = r - QUIET;
+      const botR = r - QUIET + 1;
+      const col = c2 - QUIET;
+      const top = topR >= 0 && topR < size && col >= 0 && col < size ? final[topR][col] : 0;
+      const bot = botR >= 0 && botR < size && col >= 0 && col < size ? final[botR][col] : 0;
+      if (top && bot) {
+        line += "\u2588";
+      } else if (top && !bot) {
+        line += "\u2580";
+      } else if (!top && bot) {
+        line += "\u2584";
+      } else {
+        line += " ";
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function printQR(data, indent = 4) {
+  const pad = " ".repeat(indent);
+  try {
+    const lines = generateQR(data);
+    for (const line of lines) {
+      console.log(pad + line);
+    }
+  } catch {
+    console.log(pad + "(QR code unavailable \u2014 use the link below)");
+  }
+}
+
+// src/lib/http.ts
+import { request } from "node:http";
+function httpGet(port, path3, timeoutMs = 3e3) {
+  return new Promise((resolve2) => {
+    const req = request(
+      { hostname: "localhost", port, path: path3, method: "GET", timeout: timeoutMs },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => body += chunk.toString());
+        res.on("end", () => {
+          try {
+            resolve2(JSON.parse(body));
+          } catch {
+            resolve2(null);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve2(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(null);
+    });
+    req.end();
+  });
+}
+function httpPost(port, path3, body) {
+  return new Promise((resolve2, reject) => {
+    const payload = body ? JSON.stringify(body) : "";
+    const req = request(
+      {
+        hostname: "localhost",
+        port,
+        path: path3,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 5e3
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk.toString());
+        res.on("end", () => {
+          if (res.statusCode !== 200) {
+            reject(new Error(`${path3} returned ${res.statusCode}: ${data}`));
+            return;
+          }
+          try {
+            resolve2(JSON.parse(data));
+          } catch {
+            reject(new Error(`Invalid JSON from ${path3}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`Timeout: ${path3}`));
+    });
+    req.end(payload);
+  });
+}
+
+// src/lib/format.ts
+function formatUptime(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+function formatTimeAgo(isoDate) {
+  const diff = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/pair.ts
+async function showPairCode(backendPort) {
+  const pairData = await httpPost(
+    backendPort,
+    "/api/remote-auth/generate-pair-code"
+  );
+  const pairingUrl = `https://app.deusmachine.ai/pair?code=${encodeURIComponent(pairData.code)}`;
+  const expiresMin = Math.floor(pairData.expires_in_seconds / 60);
+  blank();
+  divider("Connect from anywhere");
+  blank();
+  hint("Scan QR code or open the link:");
+  blank();
+  printQR(pairingUrl, 4);
+  blank();
+  console.log(`    ${c.cyan(c.underline(pairingUrl))}`);
+  blank();
+  hint("Or enter code manually:");
+  blank();
+  box([`    ${c.bold(c.brightWhite(pairData.code))}    `], {
+    borderColor: c.cyan,
+    width: pairData.code.length + 10
+  });
+  blank();
+  hint(`Expires in ${expiresMin} minutes.`);
+  blank();
+  divider();
+}
+async function pair() {
+  const serverInfo = readServerInfo();
+  if (!serverInfo) {
+    error("No running Deus server found.");
+    blank();
+    hint(`Start the server first with ${c.cyan("deus start")}`);
+    blank();
+    process.exit(1);
+  }
+  try {
+    await showPairCode(serverInfo.backendPort);
+  } catch (err) {
+    error(`Could not generate pairing code: ${err.message}`);
+    blank();
+    hint("Make sure the Deus server is running.");
+    blank();
+    process.exit(1);
+  }
+  const devicesRes = await httpGet(
+    serverInfo.backendPort,
+    "/api/remote-auth/devices"
+  );
+  const devices = devicesRes?.devices || [];
+  if (devices.length > 0) {
+    blank();
+    divider("Connected devices");
+    blank();
+    for (const device of devices) {
+      const age = formatTimeAgo(device.last_seen_at || device.created_at);
+      console.log(`    ${c.green(sym.dot)} ${device.name}${c.dim(`     ${age}`)}`);
+    }
+    blank();
+    divider();
+    blank();
+  }
+}
+
+// src/start.ts
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname(__filename);
+async function start(options) {
+  const { dataDir } = options;
+  if (!hasCompletedOnboarding()) {
+    await runOnboarding();
+    blank();
+  }
+  const config = loadConfig();
+  const paths = resolveBundlePaths();
+  if (!paths) {
+    error("Could not find Deus bundles.");
+    blank();
+    hint(`Run ${c.cyan("bun run build:cli")} from the monorepo root first.`);
+    blank();
+    process.exit(1);
+  }
+  const nodeCmd = resolveNodeBinary();
+  const dbPath = resolveDataDir(dataDir);
+  kv("Database", c.dim(dbPath));
+  blank();
+  const children = [];
+  let status = null;
+  let shuttingDown = false;
+  let exitCode = 0;
+  function shutdown(code = 0) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    exitCode = code;
+    if (status) status.stop();
+    blank();
+    const msg = gradientText("Shutting down...", [167, 139, 250], [34, 211, 238]);
+    console.log(`  ${msg}`);
+    const exitPromises = [];
+    for (const child of children) {
+      if (child.process.exitCode === null && child.process.signalCode === null) {
+        exitPromises.push(
+          new Promise((resolve2) => {
+            child.process.once("exit", resolve2);
+            child.process.kill("SIGTERM");
+          })
+        );
+      }
+    }
+    const drainTimeout = setTimeout(() => {
+      for (const child of children) {
+        if (child.process.exitCode === null && child.process.signalCode === null) {
+          child.process.kill("SIGKILL");
+        }
+      }
+    }, 5e3);
+    Promise.all(exitPromises).finally(() => {
+      clearTimeout(drainTimeout);
+      clearServerInfo();
+      blank();
+      const bye = gradientText("Thanks for using Deus!", [167, 139, 250], [34, 211, 238]);
+      console.log(`  ${bye}`);
+      blank();
+      process.exit(exitCode);
+    });
+  }
+  process.on("SIGINT", () => shutdown());
+  process.on("SIGTERM", () => shutdown());
+  const extraEnv = {};
+  if (config.auth_method === "api_key" && config.anthropic_api_key) {
+    extraEnv.ANTHROPIC_API_KEY = config.anthropic_api_key;
+  }
+  const s1 = spinner("Starting agent server...");
+  const agentServerUrl = await startProcess({
+    name: "agent-server",
+    command: nodeCmd,
+    args: [paths.agentServer],
+    env: { DATABASE_PATH: dbPath, ...extraEnv },
+    waitFor: /LISTEN_URL=(.+)/,
+    children
+  });
+  if (!agentServerUrl) {
+    s1.fail("Agent server failed to start");
+    shutdown(1);
+    return;
+  }
+  s1.succeed(`Agent server ${c.dim("ready")}`);
+  const s2 = spinner("Starting backend...");
+  const backendPort = await startProcess({
+    name: "backend",
+    command: nodeCmd,
+    args: [paths.backend],
+    env: {
+      AGENT_SERVER_URL: agentServerUrl,
+      DATABASE_PATH: dbPath,
+      PORT: "0",
+      ...extraEnv
+    },
+    waitFor: /\[BACKEND_PORT\](\d+)/,
+    children
+  });
+  if (!backendPort) {
+    s2.fail("Backend failed to start");
+    shutdown(1);
+    return;
+  }
+  s2.succeed(`Backend ${c.dim("ready")}`);
+  const port = parseInt(backendPort, 10);
+  writeServerInfo({
+    pid: process.pid,
+    backendPort: port,
+    agentServerUrl,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  blank();
+  box(
+    [
+      gradientText("Deus is running", [167, 139, 250], [34, 211, 238]),
+      "",
+      `API  ${c.dim(`http://localhost:${port}`)}`
+    ],
+    { borderColor: c.cyan, width: 38 }
+  );
+  blank();
+  if (config.relay_enabled) {
+    await sleep(1500);
+    try {
+      await showPairCode(port);
+    } catch {
+      blank();
+      warn("Could not generate pairing code.");
+      hint(`Run ${c.cyan("deus pair")} to try again once the relay connects.`);
+      blank();
+    }
+  } else {
+    blank();
+    hint(`Remote access is disabled. Run ${c.cyan("deus login")} to re-run setup and enable it.`);
+    blank();
+  }
+  blank();
+  const startedAt = /* @__PURE__ */ new Date();
+  status = statusLine(() => {
+    const elapsed = formatUptime(Date.now() - startedAt.getTime());
+    return `${c.dim(`Running for ${elapsed}`)}  ${c.dim(`${sym.bullet} Ctrl+C to stop`)}`;
+  }, 2e3);
+  for (const child of children) {
+    child.process.on("exit", (code, signal) => {
+      if (!shuttingDown) {
+        blank();
+        warn(
+          `${child.name} exited unexpectedly${signal ? ` (${signal})` : code ? ` (code ${code})` : ""}`
+        );
+        shutdown(1);
+      }
+    });
+  }
+  await new Promise(() => {
+  });
+}
+function resolveBundlePaths() {
+  const cliRoot = resolve(__dirname, "..");
+  const bundledDir = join3(cliRoot, "bundles");
+  if (existsSync4(join3(bundledDir, "agent-server.bundled.cjs"))) {
+    return {
+      agentServer: join3(bundledDir, "agent-server.bundled.cjs"),
+      backend: join3(bundledDir, "server.bundled.cjs")
+    };
+  }
+  const monorepoRoot = resolve(cliRoot, "../..");
+  const runtimePaths = resolveRuntimeStagePaths(monorepoRoot);
+  try {
+    validateRuntimeStage({ projectRoot: monorepoRoot, log: () => {
+    } });
+    return {
+      agentServer: runtimePaths.common.agentServerBundle,
+      backend: runtimePaths.common.backendBundle
+    };
+  } catch (error2) {
+    warn(
+      `Staged runtime is missing or stale in monorepo mode: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  return null;
+}
+function resolveDataDir(customDir) {
+  const dir = customDir ?? resolveDefaultDataDir({
+    platform: process.platform,
+    homeDir: homedir3(),
+    appData: process.env.APPDATA,
+    xdgDataHome: process.env.XDG_DATA_HOME
+  });
+  mkdirSync2(dir, { recursive: true });
+  return join3(dir, DEUS_DB_FILENAME);
+}
+function resolveNodeBinary() {
+  if (process.env.ELECTRON_RUN_AS_NODE === "1") return process.execPath;
+  try {
+    const electronPath = execSync2(
+      `node -e "try { console.log(require('electron')) } catch { process.exit(1) }"`,
+      { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (electronPath && existsSync4(electronPath)) {
+      try {
+        execSync2(
+          `node -e "const D = require('better-sqlite3'); const d = new D(':memory:'); d.close()"`,
+          { timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+        );
+        return process.execPath;
+      } catch {
+        return electronPath;
+      }
+    }
+  } catch {
+  }
+  return process.execPath;
+}
+async function startProcess(opts) {
+  const { name, command, args, env, waitFor, children, timeoutMs = 15e3 } = opts;
+  return new Promise((resolve2) => {
+    const processEnv = {};
+    if (command !== process.execPath && command.includes("Electron")) {
+      processEnv.ELECTRON_RUN_AS_NODE = "1";
+    }
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...processEnv, ...env }
+    });
+    children.push({ process: child, name });
+    let buffer = "";
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        child.kill("SIGTERM");
+        resolve2(null);
+      }
+    }, timeoutMs);
+    function onStdout(data) {
+      buffer += data.toString();
+      const match = buffer.match(waitFor);
+      if (match && !resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        child.stdout?.removeListener("data", onStdout);
+        buffer = "";
+        resolve2(match[1]);
+      }
+    }
+    child.stdout?.on("data", onStdout);
+    child.on("exit", () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve2(null);
+      }
+    });
+  });
+}
+
+// src/desktop.ts
+import { execSync as execSync3, spawn as spawn2 } from "node:child_process";
+import { createWriteStream, existsSync as existsSync5, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { tmpdir, platform as platform3, arch, homedir as homedir4 } from "node:os";
+import { get } from "node:https";
+var GITHUB_REPO = "zvadaadam/deus-machine";
+var INSTALL_PATHS = {
+  darwin: ["/Applications/Deus.app", `${homedir4()}/Applications/Deus.app`],
+  win32: [
+    `${process.env.LOCALAPPDATA || ""}\\Programs\\Deus\\Deus.exe`,
+    `${process.env.PROGRAMFILES || ""}\\Deus\\Deus.exe`
+  ],
+  linux: [`${homedir4()}/.local/bin/Deus.AppImage`, "/usr/local/bin/Deus.AppImage"]
+};
+function hasDisplay() {
+  const os = platform3();
+  if (process.env.CI || process.env.DOCKER || existsSync5("/.dockerenv")) return false;
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return false;
+  if (os === "darwin") return true;
+  if (os === "win32") return true;
+  if (os === "linux") return !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+  return false;
+}
+function findInstalledApp() {
+  const os = platform3();
+  const paths = INSTALL_PATHS[os] || [];
+  for (const p of paths) {
+    if (p && existsSync5(p)) return p;
+  }
+  return null;
+}
+function launchDesktop(appPath) {
+  const os = platform3();
+  switch (os) {
+    case "darwin":
+      spawn2("open", [appPath], { detached: true, stdio: "ignore" }).unref();
+      break;
+    case "win32":
+    case "linux":
+      spawn2(appPath, [], { detached: true, stdio: "ignore" }).unref();
+      break;
+  }
+}
+function replaceInstalledMacApp(appPath, destPath) {
+  const stagedPath = `${destPath}.staged`;
+  const backupPath = `${destPath}.backup`;
+  const hadExistingInstall = existsSync5(destPath);
+  execSync3(`rm -rf "${stagedPath}" "${backupPath}"`, { stdio: "pipe" });
+  execSync3(`ditto "${appPath}" "${stagedPath}"`, { stdio: "pipe" });
+  if (hadExistingInstall) {
+    execSync3(`mv "${destPath}" "${backupPath}"`, { stdio: "pipe" });
+  }
+  try {
+    execSync3(`mv "${stagedPath}" "${destPath}"`, { stdio: "pipe" });
+    if (hadExistingInstall) {
+      execSync3(`rm -rf "${backupPath}"`, { stdio: "pipe" });
+    }
+  } catch (error2) {
+    execSync3(`rm -rf "${stagedPath}"`, { stdio: "pipe" });
+    if (hadExistingInstall && existsSync5(backupPath) && !existsSync5(destPath)) {
+      execSync3(`mv "${backupPath}" "${destPath}"`, { stdio: "pipe" });
+    }
+    throw error2;
+  }
+}
+async function installDesktop(options) {
+  const { version } = options;
+  const os = platform3();
+  const cpuArch = arch();
+  const assetPattern = getAssetPattern(os, cpuArch);
+  if (!assetPattern) {
+    error(`Unsupported platform: ${os} ${cpuArch}`);
+    blank();
+    hint("Supported: macOS (arm64/x64), Windows (x64), Linux (x64)");
+    hint(`Or run ${c.cyan("deus start")} to run as a headless server.`);
+    blank();
+    process.exit(1);
+  }
+  kv("Platform", `${os} ${cpuArch}`, 10);
+  kv("Package", c.dim(assetPattern.description), 10);
+  blank();
+  const s1 = spinner("Fetching latest release...");
+  const release = await fetchRelease(version);
+  if (!release) {
+    s1.fail("Could not find a release on GitHub");
+    blank();
+    hint(`Repo: ${c.dim(GITHUB_REPO)}`);
+    hint("Make sure the repository has published releases.");
+    hint(`Or run ${c.cyan("deus start")} to run as a headless server.`);
+    blank();
+    process.exit(1);
+  }
+  s1.succeed(`Found release ${c.cyan(release.tag_name)}`);
+  const asset = release.assets.find((a) => assetPattern.matcher(a.name));
+  if (!asset) {
+    error(`No matching installer for ${os} ${cpuArch}`);
+    blank();
+    hint("Available downloads:");
+    for (const a of release.assets) {
+      hint(`  ${a.name}`);
+    }
+    blank();
+    process.exit(1);
+  }
+  const downloadDir = join4(tmpdir(), "deus-installer");
+  mkdirSync3(downloadDir, { recursive: true });
+  const downloadPath = join4(downloadDir, asset.name);
+  await downloadFile(asset.browser_download_url, downloadPath);
+  const s3 = spinner("Installing...");
+  const installed = await installForPlatform(os, downloadPath, s3);
+  try {
+    unlinkSync2(downloadPath);
+  } catch {
+  }
+  if (installed) {
+    blank();
+    success("Deus is ready!");
+    blank();
+  }
+}
+function getAssetPattern(os, cpuArch) {
+  switch (os) {
+    case "darwin": {
+      const archSuffix = cpuArch === "arm64" ? "arm64" : "x64";
+      return {
+        matcher: (name) => name.endsWith(".dmg") && name.includes(archSuffix),
+        description: `macOS DMG (${archSuffix})`
+      };
+    }
+    case "win32":
+      return {
+        matcher: (name) => name.endsWith(".exe") && !name.includes("blockmap"),
+        description: "Windows installer (exe)"
+      };
+    case "linux":
+      return {
+        matcher: (name) => name.endsWith(".AppImage"),
+        description: "Linux AppImage"
+      };
+    default:
+      return null;
+  }
+}
+async function fetchRelease(version) {
+  const endpoint = version === "latest" ? `https://api.github.com/repos/${GITHUB_REPO}/releases/latest` : `https://api.github.com/repos/${GITHUB_REPO}/releases/tags/${version}`;
+  const TIMEOUT = 3e4;
+  return new Promise((resolve2) => {
+    const req = get(
+      endpoint,
+      { headers: { "User-Agent": "deus-cli", Accept: "application/vnd.github.v3+json" } },
+      (res) => {
+        if (res.statusCode === 302 || res.statusCode === 301) {
+          const loc = res.headers.location;
+          if (loc) {
+            const req2 = get(loc, { headers: { "User-Agent": "deus-cli" } }, (r) => {
+              collectBody(r).then((b) => {
+                try {
+                  resolve2(JSON.parse(b));
+                } catch {
+                  resolve2(null);
+                }
+              });
+            });
+            req2.setTimeout(TIMEOUT, () => req2.destroy());
+            req2.on("error", () => resolve2(null));
+            return;
+          }
+        }
+        if (res.statusCode !== 200) {
+          resolve2(null);
+          return;
+        }
+        collectBody(res).then((b) => {
+          try {
+            resolve2(JSON.parse(b));
+          } catch {
+            resolve2(null);
+          }
+        });
+      }
+    );
+    req.setTimeout(TIMEOUT, () => req.destroy());
+    req.on("error", () => resolve2(null));
+  });
+}
+function collectBody(res) {
+  return new Promise((resolve2) => {
+    let body = "";
+    res.on("data", (chunk) => body += chunk.toString());
+    res.on("end", () => resolve2(body));
+    res.on("error", () => resolve2(""));
+  });
+}
+async function downloadFile(url, dest) {
+  return new Promise((resolve2, reject) => {
+    const download = (downloadUrl) => {
+      const req = get(downloadUrl, { headers: { "User-Agent": "deus-cli" } }, (res) => {
+        if (res.statusCode === 302 || res.statusCode === 301) {
+          const loc = res.headers.location;
+          res.resume();
+          if (loc) {
+            download(loc);
+            return;
+          }
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`Download failed with status ${res.statusCode}`));
+          return;
+        }
+        const totalSize = parseInt(res.headers["content-length"] || "0", 10);
+        let downloaded = 0;
+        const file = createWriteStream(dest);
+        res.on("error", (err) => file.destroy(err));
+        res.on("data", (chunk) => {
+          downloaded += chunk.length;
+          if (totalSize > 0) {
+            progressBar(
+              downloaded,
+              totalSize,
+              formatBytes(downloaded) + " / " + formatBytes(totalSize)
+            );
+          }
+        });
+        res.pipe(file);
+        file.on("close", () => {
+          if (!res.complete || totalSize > 0 && downloaded !== totalSize) {
+            reject(new Error("Download incomplete"));
+            return;
+          }
+          progressBarDone(`Downloaded ${c.dim(formatBytes(totalSize))}`);
+          resolve2();
+        });
+        file.on("error", reject);
+      });
+      req.setTimeout(12e4, () => req.destroy(new Error("Download timed out")));
+      req.on("error", reject);
+    };
+    download(url);
+  });
+}
+async function installForPlatform(os, filePath, s) {
+  switch (os) {
+    case "darwin": {
+      let mountPoint;
+      try {
+        const mountOutput = execSync3(`hdiutil attach "${filePath}" -nobrowse`, {
+          encoding: "utf-8"
+        });
+        mountPoint = mountOutput.split("\n").filter((line) => line.includes("/Volumes/")).map((line) => line.trim().split("	").pop()?.trim()).find(Boolean);
+        if (!mountPoint) {
+          s.fail("Could not mount disk image");
+          return false;
+        }
+        const appName = "Deus.app";
+        const appPath = `${mountPoint}/${appName}`;
+        const destPath = `/Applications/${appName}`;
+        if (existsSync5(appPath)) {
+          replaceInstalledMacApp(appPath, destPath);
+          s.succeed(`Installed to ${c.dim("/Applications/Deus.app")}`);
+          launchDesktop(destPath);
+        } else {
+          s.warn("DMG mounted \u2014 drag Deus to Applications to finish");
+        }
+        return true;
+      } catch {
+        s.fail("Auto-install failed \u2014 opening DMG manually");
+        execSync3(`open "${filePath}"`);
+        hint("Drag Deus.app to Applications, then launch it from Applications.");
+        return false;
+      } finally {
+        if (mountPoint) {
+          try {
+            execSync3(`hdiutil detach "${mountPoint}" -quiet`, { stdio: "pipe" });
+          } catch {
+          }
+        }
+      }
+    }
+    case "win32": {
+      s.succeed("Launching installer...");
+      spawn2(filePath, [], { detached: true, stdio: "ignore" }).unref();
+      hint("Follow the on-screen instructions to complete installation.");
+      return true;
+    }
+    case "linux": {
+      try {
+        execSync3(`chmod +x "${filePath}"`);
+        const installDir = join4(homedir4(), ".local", "bin");
+        mkdirSync3(installDir, { recursive: true });
+        const destPath = join4(installDir, "Deus.AppImage");
+        execSync3(`cp "${filePath}" "${destPath}"`);
+        s.succeed(`Installed to ${c.dim(destPath)}`);
+        launchDesktop(destPath);
+        return true;
+      } catch {
+        s.fail("Installation failed \u2014 check permissions");
+        return false;
+      }
+    }
+    default:
+      s.fail("Unsupported platform");
+      return false;
+  }
+}
+
+// src/status.ts
+async function showStatus() {
+  const serverInfo = readServerInfo();
+  if (!serverInfo) {
+    error("No running Deus server found.");
+    blank();
+    hint(`Start the server with ${c.cyan("deus start")}`);
+    blank();
+    process.exit(1);
+  }
+  const port = serverInfo.backendPort;
+  const [health, relayStatus, devicesRes, agentAuth] = await Promise.all([
+    httpGet(port, "/api/health"),
+    httpGet(port, "/api/settings/relay-status"),
+    httpGet(port, "/api/remote-auth/devices"),
+    httpGet(port, "/api/settings/agent-auth")
+  ]);
+  const isRunning = health !== null;
+  blank();
+  divider("Server");
+  blank();
+  kv("Status", isRunning ? c.green("running") : c.red("not responding"), 14);
+  kv("Port", String(port), 14);
+  kv("PID", String(serverInfo.pid), 14);
+  kv("Uptime", formatUptime(Date.now() - new Date(serverInfo.startedAt).getTime()), 14);
+  blank();
+  divider("Remote Access");
+  blank();
+  if (relayStatus) {
+    kv("Relay", relayStatus.connected ? c.green("connected") : c.yellow("disconnected"), 14);
+    if (relayStatus.serverId) {
+      kv("Server ID", c.dim(relayStatus.serverId.slice(0, 12) + "..."), 14);
+    }
+    kv("Clients", String(relayStatus.clients), 14);
+  } else {
+    kv("Relay", c.dim("unknown"), 14);
+  }
+  const devices = devicesRes?.devices || [];
+  if (devices.length > 0) {
+    blank();
+    divider("Paired Devices");
+    blank();
+    for (const device of devices) {
+      const age = formatTimeAgo(device.last_seen_at || device.created_at);
+      console.log(`    ${c.green(sym.dot)} ${device.name.padEnd(24)} ${c.dim(age)}`);
+    }
+  }
+  if (agentAuth?.agents) {
+    blank();
+    divider("AI Agents");
+    blank();
+    for (const agent of agentAuth.agents) {
+      let status;
+      if (!agent.initialized) {
+        status = c.dim("not installed");
+      } else if (agent.authenticated) {
+        const email = agent.account?.email ? c.dim(` (${agent.account.email})`) : "";
+        status = c.green("authenticated") + email;
+      } else {
+        status = c.yellow("not authenticated");
+      }
+      kv(agent.name, status, 14);
+    }
+  }
+  blank();
+  divider();
+  blank();
+}
+
+// src/cli.ts
+function printHelp(version) {
+  banner(version);
+  console.log(`  ${c.bold("Usage:")}   deus ${c.dim("[command] [options]")}`);
+  blank();
+  console.log(`  ${c.bold("Commands:")}`);
+  console.log(`    ${c.cyan("(none)")}        Auto-detect: launch desktop app or start server`);
+  console.log(
+    `    ${c.cyan("start")}        Start headless server ${c.dim("(backend + agent-server)")}`
+  );
+  console.log(`    ${c.cyan("install")}      Download and install the desktop app`);
+  console.log(`    ${c.cyan("pair")}         Generate a pairing code for remote access`);
+  console.log(`    ${c.cyan("login")}        Configure AI agent authentication`);
+  console.log(`    ${c.cyan("status")}       Show server info and connected devices`);
+  blank();
+  console.log(`  ${c.bold("Options")} ${c.dim("(start):")}`);
+  console.log(`    ${c.cyan("--data-dir")}   Directory for database and data files`);
+  blank();
+  console.log(`  ${c.bold("Options")} ${c.dim("(install):")}`);
+  console.log(
+    `    ${c.cyan("--version")}    Install a specific version ${c.dim("(default: latest)")}`
+  );
+  blank();
+  console.log(`  ${c.bold("Examples:")}`);
+  console.log(`    ${c.dim("$")} deus                    ${c.dim("# auto-detect mode")}`);
+  console.log(`    ${c.dim("$")} deus start               ${c.dim("# run headless server")}`);
+  console.log(`    ${c.dim("$")} deus install              ${c.dim("# install desktop app")}`);
+  console.log(`    ${c.dim("$")} deus pair                 ${c.dim("# generate pairing code")}`);
+  console.log(`    ${c.dim("$")} deus login                ${c.dim("# set up AI agent auth")}`);
+  console.log(`    ${c.dim("$")} deus status               ${c.dim("# show server info")}`);
+  blank();
+  console.log(`  ${c.bold("Quick start:")}`);
+  console.log(
+    `    ${c.dim("$")} npx deus-machine          ${c.dim("# just works, no install needed")}`
+  );
+  blank();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] && !args[0].startsWith("-") ? args[0] : null;
+  const commandArgs = command ? args.slice(1) : args;
+  const pkg = await Promise.resolve().then(() => (init_package(), package_exports));
+  const version = pkg.default.version;
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(version);
+    process.exit(0);
+  }
+  if (command === "help" || args.includes("--help") || args.includes("-h")) {
+    printHelp(version);
+    process.exit(0);
+  }
+  const quickCommands = ["pair", "status", "login"];
+  if (!command || !quickCommands.includes(command)) {
+    await animatedBanner(version);
+  }
+  const resolvedCommand = command ?? autoDetect();
+  switch (resolvedCommand) {
+    // ── Start headless server ──────────────────────────────────────
+    case "start":
+    case "serve": {
+      const { values } = parseArgs({
+        args: commandArgs,
+        options: {
+          "data-dir": { type: "string" }
+        },
+        strict: false
+      });
+      await start({
+        dataDir: values["data-dir"]
+      });
+      break;
+    }
+    // ── Install desktop app ────────────────────────────────────────
+    case "install":
+    case "desktop": {
+      const installedPath = findInstalledApp();
+      if (installedPath) {
+        success(`Deus is installed at ${c.dim(installedPath)}`);
+        blank();
+        launchDesktop(installedPath);
+        success("Launching Deus...");
+        blank();
+        return;
+      }
+      const { values } = parseArgs({
+        args: commandArgs,
+        options: {
+          version: { type: "string", default: "latest" }
+        },
+        strict: false
+      });
+      await installDesktop({ version: values.version });
+      break;
+    }
+    // ── Generate pairing code ──────────────────────────────────────
+    case "pair": {
+      await pair();
+      break;
+    }
+    // ── Auth setup ─────────────────────────────────────────────────
+    case "login": {
+      blank();
+      await runAuthSetup({ force: true });
+      blank();
+      break;
+    }
+    // ── Server status ──────────────────────────────────────────────
+    case "status": {
+      await showStatus();
+      break;
+    }
+    default:
+      error(`Unknown command: ${c.bold(resolvedCommand)}`);
+      blank();
+      hint(`Run ${c.cyan("deus --help")} to see available commands.`);
+      blank();
+      process.exit(1);
+  }
+}
+function autoDetect() {
+  if (!hasDisplay()) {
+    info("No display detected " + c.dim("\u2014 starting in server mode"));
+    blank();
+    return "start";
+  }
+  const installedPath = findInstalledApp();
+  if (installedPath) {
+    return "install";
+  }
+  info("Desktop environment detected " + c.dim("\u2014 installing Deus app"));
+  blank();
+  return "install";
+}
+main().catch((err) => {
+  blank();
+  error(`${err.message || err}`);
+  blank();
+  process.exit(1);
+});