buildwithnexus 0.5.2 → 0.5.4

package/dist/bin.js

@@ -20,7 +20,7 @@ __export(banner_exports, {
 import chalk from "chalk";
 function showBanner() {
   console.log(BANNER);
-  console.log(chalk.dim("  v0.5.1 \xB7 buildwithnexus.dev\n"));
+  console.log(chalk.dim("  v0.5.4 \xB7 buildwithnexus.dev\n"));
 }
 function showPhase(phase, total, description) {
   const progress = chalk.cyan(`[${phase}/${total}]`);
@@ -282,26 +282,26 @@ __export(secrets_exports, {
   saveConfig: () => saveConfig,
   saveKeys: () => saveKeys
 });
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import crypto2 from "crypto";
 function ensureHome() {
-  fs2.mkdirSync(NEXUS_HOME2, { recursive: true, mode: 448 });
-  fs2.mkdirSync(path2.join(NEXUS_HOME2, "vm", "images"), { recursive: true, mode: 448 });
-  fs2.mkdirSync(path2.join(NEXUS_HOME2, "vm", "configs"), { recursive: true, mode: 448 });
-  fs2.mkdirSync(path2.join(NEXUS_HOME2, "vm", "logs"), { recursive: true, mode: 448 });
-  fs2.mkdirSync(path2.join(NEXUS_HOME2, "ssh"), { recursive: true, mode: 448 });
+  fs3.mkdirSync(NEXUS_HOME2, { recursive: true, mode: 448 });
+  fs3.mkdirSync(path3.join(NEXUS_HOME2, "vm", "images"), { recursive: true, mode: 448 });
+  fs3.mkdirSync(path3.join(NEXUS_HOME2, "vm", "configs"), { recursive: true, mode: 448 });
+  fs3.mkdirSync(path3.join(NEXUS_HOME2, "vm", "logs"), { recursive: true, mode: 448 });
+  fs3.mkdirSync(path3.join(NEXUS_HOME2, "ssh"), { recursive: true, mode: 448 });
 }
 function generateMasterSecret() {
   return crypto2.randomBytes(32).toString("base64url");
 }
 function saveConfig(config) {
   const { masterSecret: _secret, ...safeConfig } = config;
-  fs2.writeFileSync(CONFIG_PATH, JSON.stringify(safeConfig, null, 2), { mode: 384 });
+  fs3.writeFileSync(CONFIG_PATH, JSON.stringify(safeConfig, null, 2), { mode: 384 });
 }
 function loadConfig() {
-  if (!fs2.existsSync(CONFIG_PATH)) return null;
-  return JSON.parse(fs2.readFileSync(CONFIG_PATH, "utf-8"));
+  if (!fs3.existsSync(CONFIG_PATH)) return null;
+  return JSON.parse(fs3.readFileSync(CONFIG_PATH, "utf-8"));
 }
 function saveKeys(keys) {
   const violations = validateAllKeys(keys);
@@ -309,13 +309,13 @@ function saveKeys(keys) {
     throw new DlpViolation(`Key validation failed: ${violations.join("; ")}`);
   }
   const lines = Object.entries(keys).filter(([, v]) => v).map(([k, v]) => `${k}=${v}`);
-  fs2.writeFileSync(KEYS_PATH, lines.join("\n") + "\n", { mode: 384 });
+  fs3.writeFileSync(KEYS_PATH, lines.join("\n") + "\n", { mode: 384 });
   sealKeysFile(KEYS_PATH, keys.NEXUS_MASTER_SECRET);
   audit("keys_saved", `${Object.keys(keys).filter((k) => keys[k]).length} keys saved`);
 }
 function loadKeys() {
-  if (!fs2.existsSync(KEYS_PATH)) return null;
-  const content = fs2.readFileSync(KEYS_PATH, "utf-8");
+  if (!fs3.existsSync(KEYS_PATH)) return null;
+  const content = fs3.readFileSync(KEYS_PATH, "utf-8");
   const keys = {};
   for (const line of content.split("\n")) {
     const eq = line.indexOf("=");
@@ -341,9 +341,9 @@ var init_secrets = __esm({
   "src/core/secrets.ts"() {
     "use strict";
     init_dlp();
-    NEXUS_HOME2 = process.env.NEXUS_HOME || path2.join(process.env.HOME || "~", ".buildwithnexus");
-    CONFIG_PATH = process.env.NEXUS_CONFIG_PATH || path2.join(NEXUS_HOME2, "config.json");
-    KEYS_PATH = process.env.NEXUS_KEYS_PATH || path2.join(NEXUS_HOME2, ".env.keys");
+    NEXUS_HOME2 = process.env.NEXUS_HOME || path3.join(process.env.HOME || "~", ".buildwithnexus");
+    CONFIG_PATH = process.env.NEXUS_CONFIG_PATH || path3.join(NEXUS_HOME2, "config.json");
+    KEYS_PATH = process.env.NEXUS_KEYS_PATH || path3.join(NEXUS_HOME2, ".env.keys");
   }
 });
 
@@ -360,9 +360,9 @@ __export(qemu_exports, {
   resolvePortConflicts: () => resolvePortConflicts,
   stopVm: () => stopVm
 });
-import fs3 from "fs";
+import fs4 from "fs";
 import net from "net";
-import path3 from "path";
+import path4 from "path";
 import { execa, execaSync } from "execa";
 import { select } from "@inquirer/prompts";
 import chalk5 from "chalk";
@@ -395,15 +395,15 @@ async function installQemu(platform) {
   }
 }
 async function downloadImage(platform) {
-  const imagePath = path3.join(IMAGES_DIR, platform.ubuntuImage);
-  if (fs3.existsSync(imagePath)) return imagePath;
+  const imagePath = path4.join(IMAGES_DIR, platform.ubuntuImage);
+  if (fs4.existsSync(imagePath)) return imagePath;
   const url = `${UBUNTU_BASE_URL}/${platform.ubuntuImage}`;
   await execa("curl", ["-L", "-C", "-", "-o", imagePath, "--progress-bar", url], { stdio: "inherit", env: scrubEnv() });
   return imagePath;
 }
 async function createDisk(basePath, sizeGb) {
-  const diskPath = path3.join(IMAGES_DIR, "nexus-vm-disk.qcow2");
-  if (fs3.existsSync(diskPath)) return diskPath;
+  const diskPath = path4.join(IMAGES_DIR, "nexus-vm-disk.qcow2");
+  if (fs4.existsSync(diskPath)) return diskPath;
   await execa("qemu-img", ["create", "-f", "qcow2", "-b", basePath, "-F", "qcow2", diskPath, `${sizeGb}G`], { env: scrubEnv() });
   return diskPath;
 }
@@ -497,7 +497,7 @@ async function resolvePortConflicts(ports) {
 }
 async function launchVm(platform, diskPath, initIsoPath, ram, cpus, ports) {
   const machineArgs = platform.os === "mac" ? ["-machine", "virt,gic-version=3"] : ["-machine", "pc"];
-  const biosArgs = fs3.existsSync(platform.biosPath) ? ["-bios", platform.biosPath] : [];
+  const biosArgs = fs4.existsSync(platform.biosPath) ? ["-bios", platform.biosPath] : [];
   const buildArgs = (cpuArgs) => [
     ...machineArgs,
     ...cpuArgs,
@@ -531,8 +531,8 @@ async function launchVm(platform, diskPath, initIsoPath, ram, cpus, ports) {
   return ports;
 }
 function readValidPid() {
-  if (!fs3.existsSync(PID_FILE)) return null;
-  const raw = fs3.readFileSync(PID_FILE, "utf-8").trim();
+  if (!fs4.existsSync(PID_FILE)) return null;
+  const raw = fs4.readFileSync(PID_FILE, "utf-8").trim();
   const pid = parseInt(raw, 10);
   if (!Number.isInteger(pid) || pid <= 1 || pid > 4194304) return null;
   return pid;
@@ -560,7 +560,7 @@ function stopVm() {
   if (!pid) return;
   if (!isQemuPid(pid)) {
     try {
-      fs3.unlinkSync(PID_FILE);
+      fs4.unlinkSync(PID_FILE);
     } catch {
     }
     return;
@@ -570,7 +570,7 @@ function stopVm() {
   } catch {
   }
   try {
-    fs3.unlinkSync(PID_FILE);
+    fs4.unlinkSync(PID_FILE);
   } catch {
   }
 }
@@ -583,9 +583,9 @@ var init_qemu = __esm({
     "use strict";
     init_secrets();
     init_dlp();
-    VM_DIR = path3.join(NEXUS_HOME2, "vm");
-    IMAGES_DIR = path3.join(VM_DIR, "images");
-    PID_FILE = path3.join(VM_DIR, "qemu.pid");
+    VM_DIR = path4.join(NEXUS_HOME2, "vm");
+    IMAGES_DIR = path4.join(VM_DIR, "images");
+    PID_FILE = path4.join(VM_DIR, "qemu.pid");
     UBUNTU_BASE_URL = "https://cloud-images.ubuntu.com/jammy/current";
   }
 });
@@ -602,21 +602,21 @@ __export(ssh_exports, {
   sshUploadFile: () => sshUploadFile,
   waitForSsh: () => waitForSsh
 });
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import crypto3 from "crypto";
 import { execa as execa2 } from "execa";
 import { NodeSSH } from "node-ssh";
 function getHostVerifier() {
-  if (!fs4.existsSync(PINNED_HOST_KEY)) {
+  if (!fs5.existsSync(PINNED_HOST_KEY)) {
     return (key) => {
       const fp = crypto3.createHash("sha256").update(key).digest("base64");
-      fs4.writeFileSync(PINNED_HOST_KEY, fp, { mode: 384 });
+      fs5.writeFileSync(PINNED_HOST_KEY, fp, { mode: 384 });
       audit("ssh_exec", `host key pinned: SHA256:${fp}`);
       return true;
     };
   }
-  const pinned = fs4.readFileSync(PINNED_HOST_KEY, "utf-8").trim();
+  const pinned = fs5.readFileSync(PINNED_HOST_KEY, "utf-8").trim();
   return (key) => {
     const fp = crypto3.createHash("sha256").update(key).digest("base64");
     const match = fp === pinned;
@@ -628,11 +628,11 @@ function getKeyPath() {
   return SSH_KEY;
 }
 function getPubKey() {
-  return fs4.readFileSync(SSH_PUB_KEY, "utf-8").trim();
+  return fs5.readFileSync(SSH_PUB_KEY, "utf-8").trim();
 }
 async function generateSshKey() {
-  if (fs4.existsSync(SSH_KEY)) return;
-  fs4.mkdirSync(SSH_DIR, { recursive: true });
+  if (fs5.existsSync(SSH_KEY)) return;
+  fs5.mkdirSync(SSH_DIR, { recursive: true });
   await execa2("ssh-keygen", [
     "-t",
     "ed25519",
@@ -644,13 +644,13 @@ async function generateSshKey() {
     "buildwithnexus@localhost",
     "-q"
   ], { env: scrubEnv() });
-  fs4.chmodSync(SSH_KEY, 384);
-  fs4.chmodSync(SSH_PUB_KEY, 420);
+  fs5.chmodSync(SSH_KEY, 384);
+  fs5.chmodSync(SSH_PUB_KEY, 420);
 }
 function addSshConfig(port) {
-  const sshConfigPath = path4.join(process.env.HOME || "~", ".ssh", "config");
-  const sshDir = path4.dirname(sshConfigPath);
-  fs4.mkdirSync(sshDir, { recursive: true });
+  const sshConfigPath = path5.join(process.env.HOME || "~", ".ssh", "config");
+  const sshDir = path5.dirname(sshConfigPath);
+  fs5.mkdirSync(sshDir, { recursive: true });
   const block = [
     "",
     "Host nexus-vm",
@@ -663,12 +663,12 @@ function addSshConfig(port) {
     "    ServerAliveInterval 60",
     ""
   ].join("\n");
-  if (fs4.existsSync(sshConfigPath)) {
-    const existing = fs4.readFileSync(sshConfigPath, "utf-8");
+  if (fs5.existsSync(sshConfigPath)) {
+    const existing = fs5.readFileSync(sshConfigPath, "utf-8");
     if (existing.includes("Host nexus-vm")) return;
-    fs4.appendFileSync(sshConfigPath, block);
+    fs5.appendFileSync(sshConfigPath, block);
   } else {
-    fs4.writeFileSync(sshConfigPath, block, { mode: 384 });
+    fs5.writeFileSync(sshConfigPath, block, { mode: 384 });
   }
 }
 async function waitForSsh(port, timeoutMs = 3e5) {
@@ -736,11 +736,11 @@ var init_ssh = __esm({
     "use strict";
     init_secrets();
     init_dlp();
-    SSH_DIR = path4.join(NEXUS_HOME2, "ssh");
-    SSH_KEY = path4.join(SSH_DIR, "id_nexus_vm");
-    SSH_PUB_KEY = path4.join(SSH_DIR, "id_nexus_vm.pub");
-    KNOWN_HOSTS = path4.join(SSH_DIR, "known_hosts_nexus_vm");
-    PINNED_HOST_KEY = path4.join(SSH_DIR, "vm_host_key.pin");
+    SSH_DIR = path5.join(NEXUS_HOME2, "ssh");
+    SSH_KEY = path5.join(SSH_DIR, "id_nexus_vm");
+    SSH_PUB_KEY = path5.join(SSH_DIR, "id_nexus_vm.pub");
+    KNOWN_HOSTS = path5.join(SSH_DIR, "known_hosts_nexus_vm");
+    PINNED_HOST_KEY = path5.join(SSH_DIR, "vm_host_key.pin");
   }
 });
 
@@ -799,6 +799,39 @@ var log = {
 init_dlp();
 import { input, confirm, password } from "@inquirer/prompts";
 import chalk4 from "chalk";
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+function loadInitConfigFromDisk() {
+  const homeDir = os.homedir();
+  const configPath = path2.join(homeDir, ".buildwithnexus", "config.json");
+  const keysPath = path2.join(homeDir, ".buildwithnexus", ".env.keys");
+  if (!fs2.existsSync(configPath)) return null;
+  try {
+    const configData = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const keysData = {};
+    if (fs2.existsSync(keysPath)) {
+      const keysContent = fs2.readFileSync(keysPath, "utf-8");
+      keysContent.split("\n").forEach((line) => {
+        const [key, ...valueParts] = line.split("=");
+        if (key && valueParts.length > 0) {
+          keysData[key] = valueParts.join("=");
+        }
+      });
+    }
+    return {
+      anthropicKey: keysData["ANTHROPIC_API_KEY"] || "",
+      openaiKey: keysData["OPENAI_API_KEY"] || "",
+      googleKey: keysData["GOOGLE_API_KEY"] || "",
+      vmRam: configData.vmRam || 4,
+      vmCpus: configData.vmCpus || 2,
+      vmDisk: configData.vmDisk || 10,
+      enableTunnel: configData.enableTunnel !== false
+    };
+  } catch {
+    return null;
+  }
+}
 async function promptInitConfig() {
   console.log(chalk4.bold("\n  API Keys\n"));
   const anthropicKey = await password({
@@ -892,10 +925,10 @@ async function promptInitConfig() {
 }
 
 // src/core/platform.ts
-import os from "os";
+import os2 from "os";
 function detectPlatform() {
-  const platform = os.platform();
-  const arch = os.arch();
+  const platform = os2.platform();
+  const arch = os2.arch();
   if (platform === "darwin") {
     return {
       os: "mac",
@@ -937,12 +970,12 @@ init_ssh();
 // src/core/cloudinit.ts
 init_secrets();
 init_dlp();
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import ejs from "ejs";
 import { execa as execa3 } from "execa";
-var CONFIGS_DIR = path5.join(NEXUS_HOME2, "vm", "configs");
-var IMAGES_DIR2 = path5.join(NEXUS_HOME2, "vm", "images");
+var CONFIGS_DIR = path6.join(NEXUS_HOME2, "vm", "configs");
+var IMAGES_DIR2 = path6.join(NEXUS_HOME2, "vm", "images");
 async function renderCloudInit(data, templateContent) {
   const trimmedPubKey = data.sshPubKey.trim();
   if (!/^(ssh-ed25519|ssh-rsa|ecdsa-sha2-nistp\d+) [A-Za-z0-9+/=]+ ?\S*$/.test(trimmedPubKey)) {
@@ -954,15 +987,15 @@ async function renderCloudInit(data, templateContent) {
   }
   const safeData = { ...data, sshPubKey: yamlEscape(trimmedPubKey), keys: safeKeys };
   const rendered = ejs.render(templateContent, safeData);
-  const outputPath = path5.join(CONFIGS_DIR, "user-data.yaml");
-  fs5.writeFileSync(outputPath, rendered, { mode: 384 });
+  const outputPath = path6.join(CONFIGS_DIR, "user-data.yaml");
+  fs6.writeFileSync(outputPath, rendered, { mode: 384 });
   audit("cloudinit_rendered", "user-data.yaml written");
   return outputPath;
 }
 async function createCloudInitIso(userDataPath) {
-  const metaDataPath = path5.join(CONFIGS_DIR, "meta-data.yaml");
-  fs5.writeFileSync(metaDataPath, "instance-id: nexus-vm-1\nlocal-hostname: nexus-vm\n", { mode: 384 });
-  const isoPath = path5.join(IMAGES_DIR2, "init.iso");
+  const metaDataPath = path6.join(CONFIGS_DIR, "meta-data.yaml");
+  fs6.writeFileSync(metaDataPath, "instance-id: nexus-vm-1\nlocal-hostname: nexus-vm\n", { mode: 384 });
+  const isoPath = path6.join(IMAGES_DIR2, "init.iso");
   const env = scrubEnv();
   try {
     let created = false;
@@ -985,10 +1018,10 @@ async function createCloudInitIso(userDataPath) {
     }
     if (!created) {
       try {
-        const stagingDir = path5.join(CONFIGS_DIR, "cidata-staging");
-        fs5.mkdirSync(stagingDir, { recursive: true, mode: 448 });
-        fs5.copyFileSync(userDataPath, path5.join(stagingDir, "user-data"));
-        fs5.copyFileSync(metaDataPath, path5.join(stagingDir, "meta-data"));
+        const stagingDir = path6.join(CONFIGS_DIR, "cidata-staging");
+        fs6.mkdirSync(stagingDir, { recursive: true, mode: 448 });
+        fs6.copyFileSync(userDataPath, path6.join(stagingDir, "user-data"));
+        fs6.copyFileSync(metaDataPath, path6.join(stagingDir, "meta-data"));
         await execa3("hdiutil", [
           "makehybrid",
           "-o",
@@ -999,7 +1032,7 @@ async function createCloudInitIso(userDataPath) {
           "cidata",
           stagingDir
         ], { env });
-        fs5.rmSync(stagingDir, { recursive: true, force: true });
+        fs6.rmSync(stagingDir, { recursive: true, force: true });
         created = true;
       } catch {
       }
@@ -1009,16 +1042,16 @@ async function createCloudInitIso(userDataPath) {
         "Cannot create cloud-init ISO: none of mkisofs, genisoimage, or hdiutil are available. On macOS, install cdrtools: brew install cdrtools. On Linux: sudo apt install genisoimage"
       );
     }
-    fs5.chmodSync(isoPath, 384);
+    fs6.chmodSync(isoPath, 384);
     audit("cloudinit_iso_created", "init.iso created");
     return isoPath;
   } finally {
     try {
-      fs5.unlinkSync(userDataPath);
+      fs6.unlinkSync(userDataPath);
     } catch {
     }
     try {
-      fs5.unlinkSync(metaDataPath);
+      fs6.unlinkSync(metaDataPath);
     } catch {
     }
     audit("cloudinit_plaintext_deleted", "user-data.yaml and meta-data.yaml removed");
@@ -1199,25 +1232,25 @@ async function stopTunnel(sshPort) {
 // src/commands/init.ts
 init_dlp();
 init_ssh();
-import fs6 from "fs";
-import path6 from "path";
-import os2 from "os";
+import fs7 from "fs";
+import path7 from "path";
+import os3 from "os";
 import crypto4 from "crypto";
 import { fileURLToPath } from "url";
 function getReleaseTarball() {
-  const dir = path6.dirname(fileURLToPath(import.meta.url));
-  const tarballPath = path6.join(dir, "nexus-release.tar.gz");
-  if (fs6.existsSync(tarballPath)) return tarballPath;
-  const rootPath = path6.resolve(dir, "..", "dist", "nexus-release.tar.gz");
-  if (fs6.existsSync(rootPath)) return rootPath;
+  const dir = path7.dirname(fileURLToPath(import.meta.url));
+  const tarballPath = path7.join(dir, "nexus-release.tar.gz");
+  if (fs7.existsSync(tarballPath)) return tarballPath;
+  const rootPath = path7.resolve(dir, "..", "dist", "nexus-release.tar.gz");
+  if (fs7.existsSync(rootPath)) return rootPath;
   throw new Error("nexus-release.tar.gz not found. Run: npm run bundle");
 }
 function getCloudInitTemplate() {
-  const dir = path6.dirname(fileURLToPath(import.meta.url));
-  const templatePath = path6.join(dir, "templates", "cloud-init.yaml.ejs");
-  if (fs6.existsSync(templatePath)) return fs6.readFileSync(templatePath, "utf-8");
-  const srcPath = path6.resolve(dir, "..", "src", "templates", "cloud-init.yaml.ejs");
-  return fs6.readFileSync(srcPath, "utf-8");
+  const dir = path7.dirname(fileURLToPath(import.meta.url));
+  const templatePath = path7.join(dir, "templates", "cloud-init.yaml.ejs");
+  if (fs7.existsSync(templatePath)) return fs7.readFileSync(templatePath, "utf-8");
+  const srcPath = path7.resolve(dir, "..", "src", "templates", "cloud-init.yaml.ejs");
+  return fs7.readFileSync(srcPath, "utf-8");
 }
 async function withSpinner(spinner, label, fn) {
   spinner.text = label;
@@ -1235,7 +1268,11 @@ var phases = [
       const platform = detectPlatform();
       log.detail("Platform", `${platform.os} ${platform.arch}`);
       log.detail("QEMU", platform.qemuBinary);
-      const userConfig = await promptInitConfig();
+      const isNonInteractive = process.env.BUILDWITHNEXUS_NONINTERACTIVE === "1" || process.env.CI === "true";
+      let userConfig = isNonInteractive ? loadInitConfigFromDisk() : null;
+      if (!userConfig) {
+        userConfig = await promptInitConfig();
+      }
       ensureHome();
       const masterSecret = generateMasterSecret();
       const config = {
@@ -1371,15 +1408,15 @@ var phases = [
       );
       await withSpinner(spinner, "Staging API keys...", async () => {
         const keysContent = Object.entries(keys).filter(([, v]) => v).map(([k, v]) => `${k}=${v}`).join("\n") + "\n";
-        const tmpKeysPath = path6.join(os2.tmpdir(), `.nexus-keys-${crypto4.randomBytes(8).toString("hex")}`);
-        fs6.writeFileSync(tmpKeysPath, keysContent, { mode: 384 });
+        const tmpKeysPath = path7.join(os3.tmpdir(), `.nexus-keys-${crypto4.randomBytes(8).toString("hex")}`);
+        fs7.writeFileSync(tmpKeysPath, keysContent, { mode: 384 });
         try {
           await sshUploadFile(config.sshPort, tmpKeysPath, "/tmp/.nexus-env-keys");
           await sshExec(config.sshPort, "chmod 600 /tmp/.nexus-env-keys");
         } finally {
           try {
-            fs6.writeFileSync(tmpKeysPath, "0".repeat(keysContent.length));
-            fs6.unlinkSync(tmpKeysPath);
+            fs7.writeFileSync(tmpKeysPath, "0".repeat(keysContent.length));
+            fs7.unlinkSync(tmpKeysPath);
           } catch {
           }
         }
@@ -1500,7 +1537,7 @@ init_secrets();
 init_qemu();
 init_ssh();
 init_secrets();
-import path7 from "path";
+import path8 from "path";
 var startCommand = new Command2("start").description("Start the NEXUS runtime").action(async () => {
   const config = loadConfig();
   if (!config) {
@@ -1512,8 +1549,8 @@ var startCommand = new Command2("start").description("Start the NEXUS runtime").
     return;
   }
   const platform = detectPlatform();
-  const diskPath = path7.join(NEXUS_HOME2, "vm", "images", "nexus-vm-disk.qcow2");
-  const isoPath = path7.join(NEXUS_HOME2, "vm", "images", "init.iso");
+  const diskPath = path8.join(NEXUS_HOME2, "vm", "images", "nexus-vm-disk.qcow2");
+  const isoPath = path8.join(NEXUS_HOME2, "vm", "images", "init.iso");
   let spinner = createSpinner("Starting VM...");
   spinner.start();
   await launchVm(platform, diskPath, isoPath, config.vmRam, config.vmCpus, {
@@ -1629,10 +1666,10 @@ var statusCommand = new Command4("status").description("Check NEXUS runtime heal
 // src/commands/doctor.ts
 import { Command as Command5 } from "commander";
 import chalk8 from "chalk";
-import fs7 from "fs";
+import fs8 from "fs";
 init_qemu();
 init_secrets();
-import path8 from "path";
+import path9 from "path";
 import { execa as execa4 } from "execa";
 var doctorCommand = new Command5("doctor").description("Diagnose NEXUS runtime environment").action(async () => {
   const platform = detectPlatform();
@@ -1662,11 +1699,11 @@ var doctorCommand = new Command5("doctor").description("Diagnose NEXUS runtime e
   } catch {
   }
   console.log(`  ${check(isoTool)}  ISO tool (mkisofs/genisoimage)`);
-  const keyExists = fs7.existsSync(path8.join(NEXUS_HOME2, "ssh", "id_nexus_vm"));
+  const keyExists = fs8.existsSync(path9.join(NEXUS_HOME2, "ssh", "id_nexus_vm"));
   console.log(`  ${check(keyExists)}  SSH key`);
   const config = loadConfig();
   console.log(`  ${check(!!config)}  Configuration`);
-  const diskExists = fs7.existsSync(path8.join(NEXUS_HOME2, "vm", "images", "nexus-vm-disk.qcow2"));
+  const diskExists = fs8.existsSync(path9.join(NEXUS_HOME2, "vm", "images", "nexus-vm-disk.qcow2"));
   console.log(`  ${check(diskExists)}  VM disk image`);
   if (config) {
     for (const [name, port] of [["SSH", config.sshPort], ["HTTP", config.httpPort], ["HTTPS", config.httpsPort]]) {
@@ -1687,7 +1724,7 @@ var doctorCommand = new Command5("doctor").description("Diagnose NEXUS runtime e
       }
     }
   }
-  const biosOk = fs7.existsSync(platform.biosPath);
+  const biosOk = fs8.existsSync(platform.biosPath);
   console.log(`  ${check(biosOk)}  UEFI firmware ${biosOk ? "" : chalk8.dim(platform.biosPath)}`);
   console.log("");
   if (qemuOk && isoTool && biosOk) {
@@ -1738,18 +1775,18 @@ var logsCommand = new Command6("logs").description("View NEXUS server logs").opt
 
 // src/commands/update.ts
 import { Command as Command7 } from "commander";
-import path9 from "path";
-import fs8 from "fs";
+import path10 from "path";
+import fs9 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 init_secrets();
 init_qemu();
 init_ssh();
 function getReleaseTarball2() {
-  const dir = path9.dirname(fileURLToPath2(import.meta.url));
-  const tarballPath = path9.join(dir, "nexus-release.tar.gz");
-  if (fs8.existsSync(tarballPath)) return tarballPath;
-  const rootPath = path9.resolve(dir, "..", "dist", "nexus-release.tar.gz");
-  if (fs8.existsSync(rootPath)) return rootPath;
+  const dir = path10.dirname(fileURLToPath2(import.meta.url));
+  const tarballPath = path10.join(dir, "nexus-release.tar.gz");
+  if (fs9.existsSync(tarballPath)) return tarballPath;
+  const rootPath = path10.resolve(dir, "..", "dist", "nexus-release.tar.gz");
+  if (fs9.existsSync(rootPath)) return rootPath;
   throw new Error("nexus-release.tar.gz not found. Reinstall buildwithnexus to get the latest release.");
 }
 var updateCommand = new Command7("update").description("Update NEXUS to the latest bundled release and restart").action(async () => {
@@ -1800,11 +1837,11 @@ var updateCommand = new Command7("update").description("Update NEXUS to the late
 // src/commands/destroy.ts
 import { Command as Command8 } from "commander";
 import chalk9 from "chalk";
-import fs9 from "fs";
+import fs10 from "fs";
 import { input as input2 } from "@inquirer/prompts";
 init_secrets();
 init_qemu();
-import path10 from "path";
+import path11 from "path";
 var destroyCommand = new Command8("destroy").description("Remove NEXUS VM and all data").option("--force", "Skip confirmation").action(async (opts) => {
   const config = loadConfig();
   if (!opts.force) {
@@ -1832,9 +1869,9 @@ var destroyCommand = new Command8("destroy").description("Remove NEXUS VM and al
     }
     stopVm();
   }
-  const sshConfigPath = path10.join(process.env.HOME || "~", ".ssh", "config");
-  if (fs9.existsSync(sshConfigPath)) {
-    const content = fs9.readFileSync(sshConfigPath, "utf-8");
+  const sshConfigPath = path11.join(process.env.HOME || "~", ".ssh", "config");
+  if (fs10.existsSync(sshConfigPath)) {
+    const content = fs10.readFileSync(sshConfigPath, "utf-8");
     const lines = content.split("\n");
     const filtered = [];
     let skip = false;
@@ -1847,9 +1884,9 @@ var destroyCommand = new Command8("destroy").description("Remove NEXUS VM and al
       skip = false;
       filtered.push(line);
     }
-    fs9.writeFileSync(sshConfigPath, filtered.join("\n"));
+    fs10.writeFileSync(sshConfigPath, filtered.join("\n"));
   }
-  fs9.rmSync(NEXUS_HOME2, { recursive: true, force: true });
+  fs10.rmSync(NEXUS_HOME2, { recursive: true, force: true });
   succeed(spinner, "NEXUS runtime destroyed");
   log.dim("Run 'buildwithnexus init' to set up again");
 });
@@ -2262,10 +2299,10 @@ init_dlp();
 // src/ui/repl.ts
 init_secrets();
 import readline from "readline";
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import chalk13 from "chalk";
-var HISTORY_FILE = path11.join(NEXUS_HOME2, "shell_history");
+var HISTORY_FILE = path12.join(NEXUS_HOME2, "shell_history");
 var MAX_HISTORY = 1e3;
 var Repl = class {
   rl = null;
@@ -2281,17 +2318,17 @@ var Repl = class {
   }
   loadHistory() {
     try {
-      if (fs10.existsSync(HISTORY_FILE)) {
-        this.history = fs10.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter(Boolean).slice(-MAX_HISTORY);
+      if (fs11.existsSync(HISTORY_FILE)) {
+        this.history = fs11.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter(Boolean).slice(-MAX_HISTORY);
       }
     } catch {
     }
   }
   saveHistory() {
     try {
-      const dir = path11.dirname(HISTORY_FILE);
-      fs10.mkdirSync(dir, { recursive: true });
-      fs10.writeFileSync(HISTORY_FILE, this.history.slice(-MAX_HISTORY).join("\n") + "\n", { mode: 384 });
+      const dir = path12.dirname(HISTORY_FILE);
+      fs11.mkdirSync(dir, { recursive: true });
+      fs11.writeFileSync(HISTORY_FILE, this.history.slice(-MAX_HISTORY).join("\n") + "\n", { mode: 384 });
     } catch {
     }
   }
@@ -2906,7 +2943,7 @@ var shellCommand2 = new Command13("shell").description("Launch the interactive N
 });
 
 // src/cli.ts
-var cli = new Command14().name("buildwithnexus").description("Auto-scaffold and launch a fully autonomous NEXUS runtime").version("0.5.1");
+var cli = new Command14().name("buildwithnexus").description("Auto-scaffold and launch a fully autonomous NEXUS runtime").version("0.5.4");
 cli.addCommand(initCommand);
 cli.addCommand(startCommand);
 cli.addCommand(stopCommand);
@@ -2935,18 +2972,18 @@ cli.action(async () => {
 });
 
 // src/core/update-notifier.ts
-import fs11 from "fs";
-import path12 from "path";
-import os3 from "os";
+import fs12 from "fs";
+import path13 from "path";
+import os4 from "os";
 import https from "https";
 import chalk16 from "chalk";
 var PACKAGE_NAME = "buildwithnexus";
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-var STATE_DIR = path12.join(os3.homedir(), ".buildwithnexus");
-var STATE_FILE = path12.join(STATE_DIR, ".update-check.json");
+var STATE_DIR = path13.join(os4.homedir(), ".buildwithnexus");
+var STATE_FILE = path13.join(STATE_DIR, ".update-check.json");
 function readState() {
   try {
-    const raw = fs11.readFileSync(STATE_FILE, "utf-8");
+    const raw = fs12.readFileSync(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { lastCheck: 0, latestVersion: null };
@@ -2954,8 +2991,8 @@ function readState() {
 }
 function writeState(state) {
   try {
-    fs11.mkdirSync(STATE_DIR, { recursive: true, mode: 448 });
-    fs11.writeFileSync(STATE_FILE, JSON.stringify(state), { mode: 384 });
+    fs12.mkdirSync(STATE_DIR, { recursive: true, mode: 448 });
+    fs12.writeFileSync(STATE_FILE, JSON.stringify(state), { mode: 384 });
   } catch {
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildwithnexus",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Launch an autonomous AI runtime with triple-nested VM isolation in one command",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build && npm run bundle"
   },
   "engines": {
     "node": ">=18"