@myerscarpenter/quest-dev 1.4.0 → 2.0.0

package/src/utils/adb.ts

@@ -5,30 +5,52 @@
 import which from 'which';
 import net from 'net';
 import { execCommand, execCommandFull } from './exec.js';
+import { verbose } from './verbose.js';
 
 const CDP_PORT = 9223; // Chrome DevTools Protocol port (Quest browser default)
 
+/** Escape a string for safe use in adb shell commands. */
+function shellEscape(s: string): string {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
+/** Global ADB device target. When set, all adb commands use -s <device>. */
+let targetDevice: string | undefined;
+
+/** Set the global ADB device target (IP:port or serial). */
+export function setAdbDevice(device: string | undefined): void {
+  targetDevice = device;
+}
+
+/** Get the global ADB device target. */
+export function getAdbDevice(): string | undefined {
+  return targetDevice;
+}
+
+/** Build ADB args with -s <device> prefix when a target device is set. */
+export function adbArgs(...args: string[]): string[] {
+  if (targetDevice) {
+    return ["-s", targetDevice, ...args];
+  }
+  return args;
+}
+
 /**
  * Get browser process PID
  */
 async function getBrowserPID(packageName: string): Promise<number | null> {
   try {
-    const result = await execCommandFull('adb', ['shell', `ps | grep ${packageName}`]);
-    if (!result.stdout) return null;
-
-    // Parse ps output: USER PID PPID ... NAME
-    const lines = result.stdout.trim().split('\n');
-    for (const line of lines) {
-      if (line.includes('grep')) continue; // Skip grep itself
-      const parts = line.trim().split(/\s+/);
-      if (parts.length >= 2) {
-        return parseInt(parts[1], 10); // PID is second column
-      }
-    }
-  } catch {
+    const result = await execCommandFull('adb', adbArgs('shell', 'pidof', shellEscape(packageName)));
+    verbose('getBrowserPID pidof output:', result.stdout?.trim());
+    if (!result.stdout?.trim()) return null;
+    const pid = parseInt(result.stdout.trim().split(/\s+/)[0], 10);
+    if (isNaN(pid)) return null;
+    verbose('getBrowserPID found PID:', pid, 'for', packageName);
+    return pid;
+  } catch (e) {
+    verbose('getBrowserPID error:', e);
     return null;
   }
-  return null;
 }
 
 /**
@@ -39,30 +61,39 @@ async function detectCDPSocket(packageName: string): Promise<string> {
   const pid = await getBrowserPID(packageName);
 
   if (pid) {
-    // Try PID-based socket first
-    try {
-      const result = await execCommandFull('adb', [
-        'shell',
-        `cat /proc/net/unix | grep chrome_devtools_remote_${pid}`
-      ]);
-      if (result.stdout.includes(`chrome_devtools_remote_${pid}`)) {
-        return `chrome_devtools_remote_${pid}`;
+    // Try PID-based socket, with retries (socket may take a moment to appear)
+    const socketName = `chrome_devtools_remote_${pid}`;
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        const result = await execCommandFull('adb', adbArgs(
+          'shell', 'cat', '/proc/net/unix',
+        ));
+        if (result.stdout.includes(socketName)) {
+          verbose('detectCDPSocket: found PID-specific socket:', socketName, `(attempt ${attempt + 1})`);
+          return socketName;
+        }
+      } catch {
+        // ignore
+      }
+      if (attempt < 4) {
+        verbose('detectCDPSocket: PID-specific socket not found yet, retrying in 1s...', `(attempt ${attempt + 1})`);
+        await new Promise(resolve => setTimeout(resolve, 1000));
       }
-    } catch {
-      // Fall through to default
     }
+    verbose('detectCDPSocket: PID-specific socket not found after retries:', socketName);
   }
 
   // Default: generic socket (Quest Browser)
+  verbose('detectCDPSocket: falling back to generic chrome_devtools_remote');
   return 'chrome_devtools_remote';
 }
 
 /**
- * Get CDP port for a socket
- * Generic socket uses 9223, PID-based uses 9222
+ * Get CDP port for a socket.
+ * Always use 9223 regardless of socket type for consistency.
  */
-function getCDPPortForSocket(socket: string): number {
-  return socket === 'chrome_devtools_remote' ? 9223 : 9222;
+function getCDPPortForSocket(_socket: string): number {
+  return CDP_PORT;
 }
 
 /**
@@ -110,9 +141,24 @@ async function restartADBServer(): Promise<boolean> {
  */
 export async function checkADBDevices(retryCount = 0): Promise<boolean> {
   try {
+    const target = getAdbDevice();
     const output = await execCommand('adb', ['devices']);
     const lines = output.trim().split('\n').slice(1); // Skip header
-    const devices = lines.filter(line => line.trim() && !line.includes('List of devices'));
+    let devices = lines.filter(line => line.trim() && !line.includes('List of devices'));
+
+    // If a target device is configured, check it's in the list
+    if (target) {
+      const targetOnline = devices.some(line => line.includes(target) && line.includes('device'));
+      if (!targetOnline) {
+        console.error(`Error: Configured device ${target} not found or offline`);
+        console.error('');
+        console.error('Check connection: adb connect ' + target);
+        console.error('');
+        process.exit(1);
+      }
+      // Filter to just the target device for the count
+      devices = devices.filter(line => line.includes(target));
+    }
 
     if (devices.length === 0) {
       console.error('Error: No ADB devices connected');
@@ -182,19 +228,19 @@ export async function ensurePortForwarding(
     const cdpPort = getCDPPortForSocket(cdpSocket);
 
     // Check reverse forwarding (Quest -> Host for dev server)
-    const reverseList = await execCommand('adb', ['reverse', '--list']);
+    const reverseList = await execCommand('adb', adbArgs('reverse', '--list'));
     const reverseExists = reverseList.includes(`tcp:${port}`);
 
     if (reverseExists) {
       console.log(`ADB reverse port forwarding already set up: Quest:${port} -> Host:${port}`);
     } else {
-      await execCommand('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
+      await execCommand('adb', adbArgs('reverse', `tcp:${port}`, `tcp:${port}`));
       console.log(`ADB reverse port forwarding set up: Quest:${port} -> Host:${port}`);
     }
 
     // Check forward forwarding (Host -> Quest for CDP)
     // First check if ADB already has this forwarding set up
-    const forwardList = await execCommand('adb', ['forward', '--list']);
+    const forwardList = await execCommand('adb', adbArgs('forward', '--list'));
     const forwardExists = forwardList.includes(`tcp:${cdpPort}`) && forwardList.includes(cdpSocket);
 
     if (forwardExists) {
@@ -214,7 +260,7 @@ export async function ensurePortForwarding(
         process.exit(1);
       }
 
-      await execCommand('adb', ['forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`]);
+      await execCommand('adb', adbArgs('forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`));
       console.log(`ADB forward port forwarding set up: Host:${cdpPort} -> Quest:${cdpSocket} (CDP)`);
     }
   } catch (error) {
@@ -228,9 +274,12 @@ export async function ensurePortForwarding(
  */
 export async function isBrowserRunning(browser: string = 'com.oculus.browser'): Promise<boolean> {
   try {
-    const result = await execCommandFull('adb', ['shell', `ps | grep ${browser}`]);
-    return result.stdout.includes(browser);
+    const result = await execCommandFull('adb', adbArgs('shell', 'pidof', shellEscape(browser)));
+    const running = result.code === 0 && result.stdout.trim().length > 0;
+    verbose('isBrowserRunning:', browser, running ? 'YES' : 'NO');
+    return running;
   } catch (error) {
+    verbose('isBrowserRunning error:', error);
     return false;
   }
 }
@@ -241,7 +290,7 @@ export async function isBrowserRunning(browser: string = 'com.oculus.browser'):
 export async function launchBrowser(url: string, browser: string = 'com.oculus.browser'): Promise<boolean> {
   console.log('Launching browser...');
   try {
-    await execCommand('adb', [
+    await execCommand('adb', adbArgs(
       'shell',
       'am',
       'start',
@@ -250,7 +299,7 @@ export async function launchBrowser(url: string, browser: string = 'com.oculus.b
       '-d',
       url,
       browser
-    ]);
+    ));
     console.log(`Browser launched with URL: ${url}`);
     return true;
   } catch (error) {
@@ -279,7 +328,7 @@ export async function ensureCDPForwarding(
     const cdpPort = getCDPPortForSocket(cdpSocket);
 
     // Check forward forwarding (Host -> Quest for CDP)
-    const forwardList = await execCommand('adb', ['forward', '--list']);
+    const forwardList = await execCommand('adb', adbArgs('forward', '--list'));
     const forwardExists = forwardList.includes(`tcp:${cdpPort}`) && forwardList.includes(cdpSocket);
 
     if (forwardExists) {
@@ -299,7 +348,7 @@ export async function ensureCDPForwarding(
         process.exit(1);
       }
 
-      await execCommand('adb', ['forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`]);
+      await execCommand('adb', adbArgs('forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`));
       console.log(`ADB forward port forwarding set up: Host:${cdpPort} -> Quest:${cdpSocket} (CDP)`);
     }
   } catch (error) {
@@ -308,12 +357,50 @@ export async function ensureCDPForwarding(
   }
 }
 
+/**
+ * Re-detect CDP socket after browser launch and update forwarding if needed.
+ * This handles the case where the initial forwarding used the generic socket
+ * (before the browser had a PID), but the browser created a PID-specific socket.
+ */
+export async function refreshCDPForwarding(
+  browser: string = 'com.oculus.browser'
+): Promise<void> {
+  try {
+    const cdpSocket = await detectCDPSocket(browser);
+    const cdpPort = getCDPPortForSocket(cdpSocket);
+
+    // Check if forwarding already points to the correct socket
+    const forwardList = await execCommand('adb', adbArgs('forward', '--list'));
+    verbose('refreshCDPForwarding: detected socket:', cdpSocket, 'port:', cdpPort);
+    verbose('refreshCDPForwarding: current forwards:', forwardList.trim());
+
+    // Check exact match: the forward line must end with the exact socket name
+    const expectedForward = `tcp:${cdpPort} localabstract:${cdpSocket}`;
+    if (forwardList.includes(expectedForward)) {
+      verbose('refreshCDPForwarding: forwarding already correct');
+      return; // Already correct
+    }
+
+    // Remove existing forwarding on CDP port and re-create with correct socket
+    if (forwardList.includes(`tcp:${cdpPort}`)) {
+      verbose('refreshCDPForwarding: removing stale forwarding on port', cdpPort);
+      await execCommandFull('adb', adbArgs('forward', '--remove', `tcp:${cdpPort}`));
+    }
+
+    await execCommand('adb', adbArgs('forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`));
+    console.log(`CDP forwarding updated: Host:${cdpPort} -> Quest:${cdpSocket}`);
+  } catch (error) {
+    // Non-fatal: CDP may still work with existing forwarding
+    console.log('Warning: Could not refresh CDP forwarding:', (error as Error).message);
+  }
+}
+
 /**
  * Check if USB file transfer is authorized on Quest
  * After reboot, user must click notification to allow file access
  */
 export async function checkUSBFileTransfer(): Promise<void> {
-  const result = await execCommandFull('adb', ['shell', 'ls', '/sdcard/']);
+  const result = await execCommandFull('adb', adbArgs('shell', 'ls', '/sdcard/'));
 
   if (result.code !== 0 ||
       result.stdout.includes('Permission denied') ||
@@ -334,7 +421,7 @@ export async function checkUSBFileTransfer(): Promise<void> {
  * Screenshots cannot be taken when the display is off
  */
 export async function checkQuestAwake(): Promise<void> {
-  const result = await execCommandFull('adb', ['shell', 'dumpsys', 'power']);
+  const result = await execCommandFull('adb', adbArgs('shell', 'dumpsys', 'power'));
 
   if (result.stdout.includes('mWakefulness=Asleep')) {
     console.error('Error: Quest display is off');
@@ -354,7 +441,7 @@ export interface BatteryInfo {
  * Get Quest battery info as structured data
  */
 export async function getBatteryInfo(): Promise<BatteryInfo> {
-  const result = await execCommandFull('adb', ['shell', 'dumpsys', 'battery']);
+  const result = await execCommandFull('adb', adbArgs('shell', 'dumpsys', 'battery'));
 
   if (result.code !== 0) {
     throw new Error('Failed to get battery status');

package/src/utils/casting-apk.ts

@@ -0,0 +1,276 @@
+/**
+ * Casting APK extraction and installation utilities.
+ *
+ * The casting service APK ships inside Meta Quest Developer Hub (MQDH).
+ *
+ * Supported MQDH sources:
+ *   - macOS: /Applications/Meta Quest Developer Hub.app (or any .app bundle)
+ *   - macOS: .dmg file (mounted, APKs extracted from the .app inside)
+ *   - Windows: .exe.zip or .exe (NSIS installer, extracted via 7z)
+ *   - Any platform: pre-extracted directory containing the APK files
+ */
+
+import { existsSync, mkdirSync, statSync, readdirSync, copyFileSync, rmSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { execCommand } from "./exec.js";
+import { verbose } from "./verbose.js";
+
+const CASTING_PKG = "com.oculus.magicislandcastingservice";
+const RELEASE_APK = "com.oculus.magicislandcastingservice.release.apk";
+const APK_DIR = join(homedir(), ".local", "share", "quest-dev");
+const RELEASE_APK_PATH = join(APK_DIR, RELEASE_APK);
+
+/** APK location inside the macOS .app bundle */
+const MACOS_APP_REL = "Contents/Resources/bin/Casting/Resources/";
+
+/** APK location inside the Windows NSIS-extracted MQDH */
+const WINDOWS_RES_REL = "resources/bin/Casting/Resources/";
+
+/** Default macOS install location */
+const MACOS_DEFAULT_APP = "/Applications/Meta Quest Developer Hub.app";
+
+/**
+ * Try to find MQDH on this machine without user input.
+ * Returns the path if found, null otherwise.
+ */
+export function findInstalledMqdh(): string | null {
+  if (platform() === "darwin") {
+    if (existsSync(MACOS_DEFAULT_APP)) {
+      return MACOS_DEFAULT_APP;
+    }
+    const userApps = join(homedir(), "Applications", "Meta Quest Developer Hub.app");
+    if (existsSync(userApps)) {
+      return userApps;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the casting APK from a MQDH source.
+ *
+ * Accepts:
+ *   - macOS .app bundle (e.g. /Applications/Meta Quest Developer Hub.app)
+ *   - macOS .dmg disk image
+ *   - Windows .exe.zip or .exe (requires 7z)
+ *   - Any directory containing the APK file
+ */
+export async function extractCastingApk(source: string): Promise<string> {
+  mkdirSync(APK_DIR, { recursive: true });
+
+  const stat = statSync(source);
+  let searchDir: string;
+
+  if (stat.isDirectory() && source.endsWith(".app")) {
+    searchDir = source;
+    verbose(`Using macOS .app bundle: ${source}`);
+  } else if (stat.isDirectory()) {
+    searchDir = source;
+  } else if (source.endsWith(".dmg")) {
+    searchDir = await extractDmg(source);
+  } else if (source.endsWith(".zip")) {
+    require7z();
+    const tmpZip = join(APK_DIR, "mqdh-zip-tmp");
+    rmSync(tmpZip, { recursive: true, force: true });
+    execFileSync("7z", ["x", `-o${tmpZip}`, source, "-y"], { stdio: "pipe" });
+    const exe = readdirSync(tmpZip).find((f) => f.endsWith(".exe"));
+    if (!exe) {
+      throw new Error("No .exe found inside zip");
+    }
+    searchDir = extractNsis(join(tmpZip, exe));
+    rmSync(tmpZip, { recursive: true, force: true });
+  } else if (source.endsWith(".exe")) {
+    require7z();
+    searchDir = extractNsis(source);
+  } else {
+    throw new Error(
+      `Unsupported file type: ${source}\n` +
+      `Supported formats: .app (macOS), .dmg (macOS), .exe.zip (Windows), .exe (Windows), or a directory`,
+    );
+  }
+
+  // Try known paths first, then fall back to recursive search
+  if (!copyApk(searchDir, [MACOS_APP_REL, WINDOWS_RES_REL])) {
+    throw new Error(
+      "Could not find casting APK. Is this the right MQDH installation?",
+    );
+  }
+
+  // Cleanup temp extraction dirs
+  for (const tmp of ["mqdh-app-tmp", "mqdh-nsis-tmp", "mqdh-zip-tmp", "mqdh-dmg-tmp"]) {
+    rmSync(join(APK_DIR, tmp), { recursive: true, force: true });
+  }
+
+  return APK_DIR;
+}
+
+/**
+ * Copy the release APK from a search directory, trying known relative paths
+ * first, then falling back to recursive search.
+ */
+function copyApk(searchDir: string, knownPaths: string[]): boolean {
+  // Try known paths first
+  for (const relPath of knownPaths) {
+    const candidate = join(searchDir, relPath, RELEASE_APK);
+    if (existsSync(candidate)) {
+      copyFileSync(candidate, RELEASE_APK_PATH);
+      return true;
+    }
+  }
+  // Fall back to recursive search
+  const found = findFile(searchDir, RELEASE_APK);
+  if (found) {
+    copyFileSync(found, RELEASE_APK_PATH);
+    return true;
+  }
+  return false;
+}
+
+/** Mount a .dmg and extract APKs from the .app inside */
+async function extractDmg(dmgPath: string): Promise<string> {
+  if (platform() !== "darwin") {
+    throw new Error(
+      ".dmg files can only be opened on macOS. On other platforms, mount the DMG and point to the .app inside.",
+    );
+  }
+
+  const mountPoint = join(APK_DIR, "mqdh-dmg-tmp");
+  rmSync(mountPoint, { recursive: true, force: true });
+  mkdirSync(mountPoint, { recursive: true });
+
+  try {
+    execFileSync("hdiutil", ["attach", dmgPath, "-mountpoint", mountPoint, "-nobrowse", "-quiet"], {
+      stdio: "pipe",
+    });
+  } catch (e) {
+    throw new Error(`Failed to mount DMG: ${(e as Error).message}`);
+  }
+
+  try {
+    const entries = readdirSync(mountPoint);
+    const app = entries.find((e) => e.endsWith(".app"));
+    if (!app) {
+      throw new Error("No .app found inside DMG");
+    }
+    return join(mountPoint, app);
+  } catch (e) {
+    try { execFileSync("hdiutil", ["detach", mountPoint, "-quiet"], { stdio: "pipe" }); } catch {}
+    throw e;
+  }
+}
+
+function require7z(): void {
+  try {
+    execFileSync("7z", ["--help"], { stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "7z is required to extract Windows MQDH installers.\n" +
+      "Install it with: sudo apt install p7zip-full (Linux) or brew install p7zip (macOS)",
+    );
+  }
+}
+
+function extractNsis(exePath: string): string {
+  const nsisDir = join(APK_DIR, "mqdh-nsis-tmp");
+  rmSync(nsisDir, { recursive: true, force: true });
+  execFileSync("7z", ["x", `-o${nsisDir}`, exePath, "-y"], { stdio: "pipe" });
+
+  const inner = join(nsisDir, "$PLUGINSDIR", "app-64.7z");
+  if (!existsSync(inner)) {
+    throw new Error("Could not find app-64.7z inside NSIS installer");
+  }
+  const appDir = join(APK_DIR, "mqdh-app-tmp");
+  rmSync(appDir, { recursive: true, force: true });
+  execFileSync("7z", ["x", `-o${appDir}`, inner, "-y"], { stdio: "pipe" });
+
+  rmSync(nsisDir, { recursive: true, force: true });
+  return appDir;
+}
+
+/** Recursively find a file by name */
+function findFile(dir: string, name: string): string | null {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    try {
+      if (statSync(full).isDirectory()) {
+        const found = findFile(full, name);
+        if (found) return found;
+      } else if (entry === name) {
+        return full;
+      }
+    } catch {
+      // Skip permission errors
+    }
+  }
+  return null;
+}
+
+/** Check whether the casting APK has been extracted locally */
+export function hasCastingApk(): boolean {
+  return existsSync(RELEASE_APK_PATH);
+}
+
+/** Check if casting service is installed on the connected Quest device */
+export async function isCastingInstalled(device: string): Promise<boolean> {
+  try {
+    const output = await execCommand("adb", [
+      "-s", device, "shell", "pm", "list", "packages", CASTING_PKG,
+    ]);
+    return output.includes(CASTING_PKG);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install the casting APK onto the Quest device.
+ *
+ * Uses the release APK which matches the system app's signing certificate.
+ * This installs as UPDATED_SYSTEM_APP, preserving privileged permissions.
+ */
+export async function installCastingApk(device: string): Promise<void> {
+  if (!hasCastingApk()) {
+    throw new Error(
+      `Casting APK not found. Run: quest-dev setup-cast`,
+    );
+  }
+
+  try {
+    await execCommand("adb", ["-s", device, "install", "-r", "-g", RELEASE_APK_PATH]);
+  } catch (error) {
+    throw new Error(
+      `Failed to install casting APK: ${(error as Error).message}\n` +
+      `Try installing manually: adb -s ${device} install -r -g ${RELEASE_APK_PATH}`,
+    );
+  }
+}
+
+/** Ensure casting service is installed, installing if needed. */
+export async function ensureCastingInstalled(device: string): Promise<boolean> {
+  if (await isCastingInstalled(device)) {
+    verbose("Casting service already installed");
+    return false;
+  }
+
+  // If we don't have the APK locally, try to find MQDH on this machine
+  if (!hasCastingApk()) {
+    const mqdh = findInstalledMqdh();
+    if (mqdh) {
+      console.log(`Found MQDH at ${mqdh}, extracting casting APK...`);
+      await extractCastingApk(mqdh);
+    } else {
+      throw new Error(
+        `Casting service not installed on Quest and APK not found locally.\n\n` +
+        `To fix this, run:\n\n` +
+        `  quest-dev setup-cast\n\n` +
+        `This will guide you through downloading and extracting the casting APK.`,
+      );
+    }
+  }
+  console.log("Installing casting service on Quest...");
+  await installCastingApk(device);
+  console.log("Casting service installed");
+  return true;
+}

package/src/utils/config.ts

@@ -1,6 +1,6 @@
 /**
  * Config file loading for quest-dev
- * Resolves settings from CLI flags → .quest-dev.json → ~/.config/quest-dev/config.json
+ * Resolves settings from CLI flags → ~/.config/quest-dev/config.json
  */
 
 import { readFileSync, writeFileSync, mkdirSync } from 'fs';
@@ -9,40 +9,25 @@ import { homedir } from 'os';
 
 export interface QuestDevConfig {
   pin?: string;
+  port?: number;
+  host?: string;
+  device?: string;
   idleTimeout?: number;
   lowBattery?: number;
 }
 
-const CONFIG_LOCATIONS = [
-  join(process.cwd(), '.quest-dev.json'),
-  join(homedir(), '.config', 'quest-dev', 'config.json'),
-];
-
-function tryReadConfig(path: string): QuestDevConfig | null {
-  try {
-    const content = readFileSync(path, 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
+const CONFIG_PATH = join(homedir(), '.config', 'quest-dev', 'config.json');
 
 /**
- * Load merged config from all config file locations.
- * First file found wins for each field.
+ * Load config from ~/.config/quest-dev/config.json
  */
 export function loadConfig(): QuestDevConfig {
-  const merged: QuestDevConfig = {};
-
-  for (const path of CONFIG_LOCATIONS) {
-    const config = tryReadConfig(path);
-    if (!config) continue;
-    if (merged.pin === undefined && config.pin) merged.pin = config.pin;
-    if (merged.idleTimeout === undefined && config.idleTimeout !== undefined) merged.idleTimeout = config.idleTimeout;
-    if (merged.lowBattery === undefined && config.lowBattery !== undefined) merged.lowBattery = config.lowBattery;
+  try {
+    const content = readFileSync(CONFIG_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return {};
   }
-
-  return merged;
 }
 
 /**
@@ -50,22 +35,19 @@ export function loadConfig(): QuestDevConfig {
  * Merges with existing config (doesn't overwrite unrelated fields).
  */
 export function saveConfig(values: QuestDevConfig): string {
-  const configPath = join(homedir(), '.config', 'quest-dev', 'config.json');
-  let existing: QuestDevConfig = {};
-  try {
-    existing = JSON.parse(readFileSync(configPath, 'utf-8'));
-  } catch {
-    // No existing config, start fresh
-  }
+  const existing = loadConfig();
 
   const merged = { ...existing };
   if (values.pin !== undefined) merged.pin = values.pin;
+  if (values.port !== undefined) merged.port = values.port;
+  if (values.host !== undefined) merged.host = values.host;
+  if (values.device !== undefined) merged.device = values.device;
   if (values.idleTimeout !== undefined) merged.idleTimeout = values.idleTimeout;
   if (values.lowBattery !== undefined) merged.lowBattery = values.lowBattery;
 
-  mkdirSync(dirname(configPath), { recursive: true });
-  writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n');
-  return configPath;
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + '\n');
+  return CONFIG_PATH;
 }
 
 /**

package/src/utils/exec.ts

@@ -46,6 +46,26 @@ export function execCommand(command: string, args: string[] = []): Promise<strin
   });
 }
 
+/**
+ * Execute a shell command with stdout/stderr streamed to the console in real time.
+ * Returns the exit code.
+ */
+export function execCommandStreaming(command: string, args: string[] = []): Promise<number> {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      stdio: 'inherit',
+    });
+
+    proc.on('close', (code) => {
+      resolve(code ?? 1);
+    });
+
+    proc.on('error', () => {
+      resolve(1);
+    });
+  });
+}
+
 /**
  * Execute a shell command and return full result (doesn't throw on non-zero exit)
  */