@myerscarpenter/quest-dev 1.0.8 → 1.2.0

package/src/commands/stay-awake.ts

@@ -0,0 +1,254 @@
+/**
+ * Quest stay-awake command
+ * Keeps Quest screen awake by setting screen timeout to 24 hours
+ * Restores original timeout on exit (Ctrl-C)
+ */
+
+import { checkADBPath } from '../utils/adb.js';
+import { execCommand } from '../utils/exec.js';
+import { execSync, spawn, ChildProcess } from 'child_process';
+import * as os from 'os';
+import * as fs from 'fs';
+
+/**
+ * Get current screen timeout setting
+ */
+async function getScreenTimeout(): Promise<number> {
+  const output = await execCommand('adb', ['shell', 'settings', 'get', 'system', 'screen_off_timeout']);
+  return parseInt(output.trim(), 10);
+}
+
+/**
+ * Set screen timeout (in milliseconds)
+ */
+async function setScreenTimeout(timeout: number): Promise<void> {
+  await execCommand('adb', ['shell', 'settings', 'put', 'system', 'screen_off_timeout', timeout.toString()]);
+}
+
+/**
+ * Disable Quest proximity sensor (keeps screen on even when not worn)
+ */
+async function disableProximitySensor(): Promise<void> {
+  await execCommand('adb', ['shell', 'am', 'broadcast', '-a', 'com.oculus.vrpowermanager.prox_close']);
+}
+
+/**
+ * Enable Quest proximity sensor (re-enable normal behavior)
+ * Note: automation_disable actually RE-ENABLES normal proximity sensor automation
+ */
+async function enableProximitySensor(): Promise<void> {
+  await execCommand('adb', ['shell', 'am', 'broadcast', '-a', 'com.oculus.vrpowermanager.automation_disable']);
+}
+
+/**
+ * Wake the Quest screen
+ */
+async function wakeScreen(): Promise<void> {
+  await execCommand('adb', ['shell', 'input', 'keyevent', 'KEYCODE_WAKEUP']);
+}
+
+/**
+ * Child watchdog process - polls for parent death and cleans up
+ */
+export async function stayAwakeWatchdog(parentPid: number, originalTimeout: number): Promise<void> {
+  const pollInterval = 5000; // Check every 5 seconds
+
+  const checkParent = setInterval(() => {
+    try {
+      // Check if parent process still exists
+      process.kill(parentPid, 0);
+      // Parent still alive, continue polling
+    } catch {
+      // Parent is dead - perform cleanup
+      console.log('Parent process died, restoring Quest settings...');
+      clearInterval(checkParent);
+
+      // Restore settings synchronously
+      try {
+        execSync(`adb shell settings put system screen_off_timeout ${originalTimeout}`, { stdio: 'ignore' });
+        execSync(`adb shell am broadcast -a com.oculus.vrpowermanager.automation_disable`, { stdio: 'ignore' });
+
+        // Cleanup PID file
+        const pidFile = `${os.homedir()}/.quest-dev-stay-awake.pid`;
+        try {
+          fs.unlinkSync(pidFile);
+        } catch {}
+
+        console.log(`Screen timeout restored to ${originalTimeout}ms (${Math.round(originalTimeout / 1000)}s)`);
+        console.log('Proximity sensor re-enabled');
+      } catch (err) {
+        console.error('Failed to restore settings:', (err as Error).message);
+      }
+
+      process.exit(0);
+    }
+  }, pollInterval);
+}
+
+/**
+ * Main stay-awake command handler
+ */
+export async function stayAwakeCommand(idleTimeout: number = 300000): Promise<void> {
+  // Check prerequisites
+  checkADBPath();
+
+  // Check devices without verbose output
+  try {
+    const output = await execCommand('adb', ['devices']);
+    const lines = output.trim().split('\n').slice(1);
+    const devices = lines.filter(line => line.trim() && !line.includes('List of devices'));
+
+    if (devices.length === 0) {
+      console.error('Error: No ADB devices connected');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('Error: Failed to list ADB devices');
+    process.exit(1);
+  }
+
+  // PID file management
+  const pidFilePath = `${os.homedir()}/.quest-dev-stay-awake.pid`;
+
+  // Check for existing process
+  if (fs.existsSync(pidFilePath)) {
+    const existingPid = parseInt(fs.readFileSync(pidFilePath, 'utf-8'));
+    try {
+      process.kill(existingPid, 0); // Test if process exists
+      console.error(`Error: stay-awake is already running (PID: ${existingPid})`);
+      process.exit(1);
+    } catch {
+      // Process dead, cleanup stale PID file
+      fs.unlinkSync(pidFilePath);
+    }
+  }
+
+  // Get original timeout
+  let originalTimeout: number;
+
+  try {
+    originalTimeout = await getScreenTimeout();
+    console.log(`Original screen timeout: ${originalTimeout}ms (${Math.round(originalTimeout / 1000)}s)`);
+  } catch (error) {
+    console.error('Failed to get current screen timeout');
+    process.exit(1);
+  }
+
+  // Write PID file
+  try {
+    fs.writeFileSync(pidFilePath, process.pid.toString());
+  } catch (error) {
+    console.warn('Failed to write PID file, hook will not work');
+  }
+
+  // Spawn child watchdog process
+  let childProcess: ChildProcess | null = null;
+  try {
+    childProcess = spawn(process.execPath, [
+      process.argv[1], // quest-dev script path
+      'stay-awake-watchdog',
+      '--parent-pid', process.pid.toString(),
+      '--original-timeout', originalTimeout.toString()
+    ], {
+      detached: true,
+      stdio: 'ignore'
+    });
+
+    childProcess.unref(); // Allow parent to exit without waiting for child
+  } catch (error) {
+    console.warn('Failed to spawn watchdog child process');
+  }
+
+  // Wake screen and disable proximity sensor
+  try {
+    await wakeScreen();
+    console.log('Quest screen woken up');
+
+    await disableProximitySensor();
+    console.log('Proximity sensor disabled');
+  } catch (error) {
+    console.error('Failed to wake screen or disable proximity sensor:', (error as Error).message);
+  }
+
+  // Set timeout to 24 hours (86400000ms)
+  const longTimeout = 86400000;
+  try {
+    await setScreenTimeout(longTimeout);
+    console.log(`Screen timeout set to 24 hours`);
+    console.log(`Quest will stay awake (idle timeout: ${Math.round(idleTimeout / 1000)}s). Press Ctrl-C to restore original settings.`);
+  } catch (error) {
+    console.error('Failed to set screen timeout');
+    process.exit(1);
+  }
+
+  // Idle timer mechanism
+  let idleTimerHandle: NodeJS.Timeout | null = null;
+  let cleanupInProgress = false;
+
+  const resetIdleTimer = () => {
+    if (idleTimerHandle) clearTimeout(idleTimerHandle);
+    idleTimerHandle = setTimeout(() => {
+      console.log('\nIdle timeout reached, exiting...');
+      cleanup();
+    }, idleTimeout);
+  };
+
+  // Set up cleanup on exit (must be synchronous for signal handlers)
+  const cleanup = () => {
+    if (cleanupInProgress) return; // Guard against double-cleanup
+    cleanupInProgress = true;
+
+    // Clear idle timer
+    if (idleTimerHandle) clearTimeout(idleTimerHandle);
+
+    // Kill child watchdog
+    if (childProcess) {
+      try {
+        childProcess.kill();
+      } catch {}
+    }
+
+    console.log('\nRestoring original settings...');
+    try {
+      // Remove PID file
+      try {
+        fs.unlinkSync(pidFilePath);
+      } catch {}
+
+      // Restore Quest settings
+      execSync(`adb shell settings put system screen_off_timeout ${originalTimeout}`, { stdio: 'ignore' });
+      execSync(`adb shell am broadcast -a com.oculus.vrpowermanager.automation_disable`, { stdio: 'ignore' });
+      console.log(`Screen timeout restored to ${originalTimeout}ms (${Math.round(originalTimeout / 1000)}s)`);
+      console.log(`Proximity sensor re-enabled`);
+    } catch (error) {
+      console.error('Failed to restore settings:', (error as Error).message);
+    }
+    process.exit(0);
+  };
+
+  // Handle Ctrl-C and termination
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('SIGHUP', cleanup);
+
+  // Handle SIGUSR1 for activity reset
+  process.on('SIGUSR1', () => {
+    console.log('Activity detected, resetting idle timer');
+    resetIdleTimer();
+  });
+
+  // Start idle timer
+  resetIdleTimer();
+
+  // Keep process running with an interval that does nothing
+  console.log('Keeping Quest awake...');
+  setInterval(() => {
+    // Do nothing, just keep process alive
+  }, 60000); // Check every minute
+
+  // Prevent process from exiting
+  await new Promise<void>((resolve) => {
+    // This will only resolve when cleanup is called
+    process.on('exit', () => resolve());
+  });
+}

package/src/index.ts

@@ -12,6 +12,9 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { screenshotCommand } from './commands/screenshot.js';
 import { openCommand } from './commands/open.js';
+import { startCommand, stopCommand, statusCommand, tailCommand } from './commands/logcat.js';
+import { batteryCommand } from './commands/battery.js';
+import { stayAwakeCommand, stayAwakeWatchdog } from './commands/stay-awake.js';
 
 // Read version from package.json
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -43,17 +46,26 @@ const cli = yargs(hideBin(process.argv))
 
 // Screenshot command
 cli.command(
-  'screenshot <output>',
-  'Take a screenshot from Quest and save to local file',
+  'screenshot <directory>',
+  'Take a screenshot from Quest and save to directory with auto-generated filename',
   (yargs) => {
-    return yargs.positional('output', {
-      describe: 'Output file path (e.g., ~/screenshots/test.jpg)',
-      type: 'string',
-      demandOption: true
-    });
+    return yargs
+      .positional('directory', {
+        describe: 'Output directory path (e.g., ~/screenshots)',
+        type: 'string',
+        demandOption: true
+      })
+      .option('caption', {
+        describe: 'Caption to embed in JPEG COM metadata',
+        type: 'string',
+        alias: 'c'
+      });
   },
   async (argv) => {
-    await screenshotCommand(argv.output as string);
+    await screenshotCommand(
+      argv.directory as string,
+      argv.caption as string | undefined
+    );
   }
 );
 
@@ -72,10 +84,108 @@ cli.command(
         describe: 'Close all other tabs before opening',
         type: 'boolean',
         default: false
+      })
+      .option('browser', {
+        describe: 'Browser package name (e.g., com.oculus.browser, org.chromium.chrome)',
+        type: 'string',
+        default: 'com.oculus.browser',
+        alias: 'b'
+      });
+  },
+  async (argv) => {
+    await openCommand(
+      argv.url as string,
+      argv.closeOthers as boolean,
+      argv.browser as string
+    );
+  }
+);
+
+// Logcat command
+cli.command(
+  'logcat <action>',
+  'Capture Android logcat to files (CRITICAL: always start before testing to avoid losing crash logs)',
+  (yargs) => {
+    return yargs
+      .positional('action', {
+        describe: 'Action to perform',
+        type: 'string',
+        choices: ['start', 'stop', 'status', 'tail'],
+        demandOption: true
+      })
+      .option('filter', {
+        describe: 'Logcat filter expression (e.g., "*:W" for warnings+, "chromium:V *:S" for chromium only)',
+        type: 'string'
+      });
+  },
+  async (argv) => {
+    const action = argv.action as string;
+    const filter = argv.filter as string | undefined;
+
+    switch (action) {
+      case 'start':
+        await startCommand(filter);
+        break;
+      case 'stop':
+        await stopCommand();
+        break;
+      case 'status':
+        await statusCommand();
+        break;
+      case 'tail':
+        await tailCommand();
+        break;
+      default:
+        console.error(`Unknown action: ${action}`);
+        process.exit(1);
+    }
+  }
+);
+
+// Battery command
+cli.command(
+  'battery',
+  'Show Quest battery percentage and charging status',
+  () => {},
+  async () => {
+    await batteryCommand();
+  }
+);
+
+// Stay-awake command
+cli.command(
+  'stay-awake',
+  'Keep Quest screen awake (sets 24hr timeout, restores on Ctrl-C)',
+  (yargs) => {
+    return yargs.option('idle-timeout', {
+      describe: 'Idle timeout in milliseconds (default: 300000 = 5 minutes)',
+      type: 'number',
+      default: 300000,
+      alias: 'i'
+    });
+  },
+  async (argv) => {
+    await stayAwakeCommand(argv.idleTimeout as number);
+  }
+);
+
+// Stay-awake watchdog (internal subcommand, spawned by stay-awake parent)
+cli.command(
+  'stay-awake-watchdog',
+  false as any, // Hide from help
+  (yargs) => {
+    return yargs
+      .option('parent-pid', {
+        type: 'number',
+        demandOption: true
+      })
+      .option('original-timeout', {
+        type: 'number',
+        demandOption: true
       });
   },
   async (argv) => {
-    await openCommand(argv.url as string, argv.closeOthers as boolean);
+    await stayAwakeWatchdog(argv.parentPid as number, argv.originalTimeout as number);
   }
 );
 

package/src/utils/adb.ts

@@ -8,13 +8,69 @@ import { execCommand, execCommandFull } from './exec.js';
 
 const CDP_PORT = 9223; // Chrome DevTools Protocol port (Quest browser default)
 
+/**
+ * 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 {
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Detect CDP socket for a browser
+ * Returns socket name (e.g., "chrome_devtools_remote_12345")
+ */
+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}`;
+      }
+    } catch {
+      // Fall through to default
+    }
+  }
+
+  // Default: generic socket (Quest Browser)
+  return 'chrome_devtools_remote';
+}
+
+/**
+ * Get CDP port for a socket
+ * Generic socket uses 9223, PID-based uses 9222
+ */
+function getCDPPortForSocket(socket: string): number {
+  return socket === 'chrome_devtools_remote' ? 9223 : 9222;
+}
+
 /**
  * Check if ADB is available on PATH
  */
 export function checkADBPath(): string {
   try {
     const adbPath = which.sync('adb');
-    console.log(`Found ADB at: ${adbPath}`);
     return adbPath;
   } catch (error) {
     console.error('Error: ADB not found in PATH');
@@ -116,8 +172,15 @@ export function isPortListening(port: number): Promise<boolean> {
 /**
  * Idempotently set up ADB port forwarding for a given port
  */
-export async function ensurePortForwarding(port: number): Promise<void> {
+export async function ensurePortForwarding(
+  port: number,
+  browser: string = 'com.oculus.browser'
+): Promise<void> {
   try {
+    // Detect CDP socket and port for this browser
+    const cdpSocket = await detectCDPSocket(browser);
+    const cdpPort = getCDPPortForSocket(cdpSocket);
+
     // Check reverse forwarding (Quest -> Host for dev server)
     const reverseList = await execCommand('adb', ['reverse', '--list']);
     const reverseExists = reverseList.includes(`tcp:${port}`);
@@ -132,27 +195,27 @@ export async function ensurePortForwarding(port: number): Promise<void> {
     // 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 forwardExists = forwardList.includes(`tcp:${CDP_PORT}`) && forwardList.includes('chrome_devtools_remote');
+    const forwardExists = forwardList.includes(`tcp:${cdpPort}`) && forwardList.includes(cdpSocket);
 
     if (forwardExists) {
-      console.log(`CDP port ${CDP_PORT} forwarding already set up`);
+      console.log(`CDP port ${cdpPort} forwarding already set up`);
     } else {
       // Check if something else is using the port
-      const cdpPortListening = await isPortListening(CDP_PORT);
+      const cdpPortListening = await isPortListening(cdpPort);
       if (cdpPortListening) {
-        console.error(`Error: Port ${CDP_PORT} is already in use by another process`);
+        console.error(`Error: Port ${cdpPort} is already in use by another process`);
         console.error('');
-        console.error('CDP port forwarding requires port 9223 to be free.');
+        console.error(`CDP port forwarding requires port ${cdpPort} to be free.`);
         console.error('Please stop the process using this port and try again.');
         console.error('');
         console.error('To find what is using the port:');
-        console.error(`  lsof -i :${CDP_PORT}`);
+        console.error(`  lsof -i :${cdpPort}`);
         console.error('');
         process.exit(1);
       }
 
-      await execCommand('adb', ['forward', `tcp:${CDP_PORT}`, 'localabstract:chrome_devtools_remote']);
-      console.log(`ADB forward port forwarding set up: Host:${CDP_PORT} -> Quest:chrome_devtools_remote (CDP)`);
+      await execCommand('adb', ['forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`]);
+      console.log(`ADB forward port forwarding set up: Host:${cdpPort} -> Quest:${cdpSocket} (CDP)`);
     }
   } catch (error) {
     console.error('Failed to set up port forwarding:', (error as Error).message);
@@ -161,22 +224,22 @@ export async function ensurePortForwarding(port: number): Promise<void> {
 }
 
 /**
- * Check if Quest browser is running
+ * Check if browser is running
  */
-export async function isBrowserRunning(): Promise<boolean> {
+export async function isBrowserRunning(browser: string = 'com.oculus.browser'): Promise<boolean> {
   try {
-    const result = await execCommandFull('adb', ['shell', 'ps | grep com.oculus.browser']);
-    return result.stdout.includes('com.oculus.browser');
+    const result = await execCommandFull('adb', ['shell', `ps | grep ${browser}`]);
+    return result.stdout.includes(browser);
   } catch (error) {
     return false;
   }
 }
 
 /**
- * Launch Quest browser with a URL using am start
+ * Launch browser with a URL using am start
  */
-export async function launchBrowser(url: string): Promise<boolean> {
-  console.log('Launching Quest browser...');
+export async function launchBrowser(url: string, browser: string = 'com.oculus.browser'): Promise<boolean> {
+  console.log('Launching browser...');
   try {
     await execCommand('adb', [
       'shell',
@@ -186,12 +249,12 @@ export async function launchBrowser(url: string): Promise<boolean> {
       'android.intent.action.VIEW',
       '-d',
       url,
-      'com.oculus.browser'
+      browser
     ]);
-    console.log(`Quest browser launched with URL: ${url}`);
+    console.log(`Browser launched with URL: ${url}`);
     return true;
   } catch (error) {
-    console.error('Failed to launch Quest browser:', (error as Error).message);
+    console.error('Failed to launch browser:', (error as Error).message);
     return false;
   }
 }
@@ -199,38 +262,45 @@ export async function launchBrowser(url: string): Promise<boolean> {
 /**
  * Get CDP port
  */
-export function getCDPPort(): number {
-  return CDP_PORT;
+export async function getCDPPort(browser: string = 'com.oculus.browser'): Promise<number> {
+  const cdpSocket = await detectCDPSocket(browser);
+  return getCDPPortForSocket(cdpSocket);
 }
 
 /**
  * Set up only CDP forwarding (for external URLs that don't need reverse forwarding)
  */
-export async function ensureCDPForwarding(): Promise<void> {
+export async function ensureCDPForwarding(
+  browser: string = 'com.oculus.browser'
+): Promise<void> {
   try {
+    // Detect CDP socket and port for this browser
+    const cdpSocket = await detectCDPSocket(browser);
+    const cdpPort = getCDPPortForSocket(cdpSocket);
+
     // Check forward forwarding (Host -> Quest for CDP)
     const forwardList = await execCommand('adb', ['forward', '--list']);
-    const forwardExists = forwardList.includes(`tcp:${CDP_PORT}`) && forwardList.includes('chrome_devtools_remote');
+    const forwardExists = forwardList.includes(`tcp:${cdpPort}`) && forwardList.includes(cdpSocket);
 
     if (forwardExists) {
-      console.log(`CDP port ${CDP_PORT} forwarding already set up`);
+      console.log(`CDP port ${cdpPort} forwarding already set up`);
     } else {
       // Check if something else is using the port
-      const cdpPortListening = await isPortListening(CDP_PORT);
+      const cdpPortListening = await isPortListening(cdpPort);
       if (cdpPortListening) {
-        console.error(`Error: Port ${CDP_PORT} is already in use by another process`);
+        console.error(`Error: Port ${cdpPort} is already in use by another process`);
         console.error('');
-        console.error('CDP port forwarding requires port 9223 to be free.');
+        console.error(`CDP port forwarding requires port ${cdpPort} to be free.`);
         console.error('Please stop the process using this port and try again.');
         console.error('');
         console.error('To find what is using the port:');
-        console.error(`  lsof -i :${CDP_PORT}`);
+        console.error(`  lsof -i :${cdpPort}`);
         console.error('');
         process.exit(1);
       }
 
-      await execCommand('adb', ['forward', `tcp:${CDP_PORT}`, 'localabstract:chrome_devtools_remote']);
-      console.log(`ADB forward port forwarding set up: Host:${CDP_PORT} -> Quest:chrome_devtools_remote (CDP)`);
+      await execCommand('adb', ['forward', `tcp:${cdpPort}`, `localabstract:${cdpSocket}`]);
+      console.log(`ADB forward port forwarding set up: Host:${cdpPort} -> Quest:${cdpSocket} (CDP)`);
     }
   } catch (error) {
     console.error('Failed to set up CDP forwarding:', (error as Error).message);
@@ -274,3 +344,50 @@ export async function checkQuestAwake(): Promise<void> {
     process.exit(1);
   }
 }
+
+/**
+ * Get Quest battery status
+ * Returns percentage and charging state in one line
+ */
+export async function getBatteryStatus(): Promise<string> {
+  const result = await execCommandFull('adb', ['shell', 'dumpsys', 'battery']);
+
+  if (result.code !== 0) {
+    throw new Error('Failed to get battery status');
+  }
+
+  // Parse battery info
+  let level = 0;
+  let acPowered = false;
+  let usbPowered = false;
+  let maxChargingCurrent = 0;
+
+  const lines = result.stdout.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('level: ')) {
+      level = parseInt(trimmed.substring(7), 10);
+    } else if (trimmed.startsWith('AC powered: ')) {
+      acPowered = trimmed.substring(12) === 'true';
+    } else if (trimmed.startsWith('USB powered: ')) {
+      usbPowered = trimmed.substring(13) === 'true';
+    } else if (trimmed.startsWith('Max charging current: ')) {
+      maxChargingCurrent = parseInt(trimmed.substring(22), 10);
+    }
+  }
+
+  // Determine charging state
+  let state: string;
+  if (acPowered || usbPowered) {
+    // Fast charging is typically > 2A (2000000 microamps)
+    if (maxChargingCurrent > 2000000) {
+      state = 'fast charging';
+    } else {
+      state = 'charging';
+    }
+  } else {
+    state = 'not charging';
+  }
+
+  return `${level}% ${state}`;
+}