@myerscarpenter/quest-dev 1.1.0 → 1.2.1

package/src/utils/adb.ts

@@ -8,6 +8,63 @@ 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
  */
@@ -115,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}`);
@@ -131,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);
@@ -160,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',
@@ -185,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;
   }
 }
@@ -198,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);
@@ -273,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}`;
+}

package/src/utils/exec.ts

@@ -17,7 +17,6 @@ export function execCommand(command: string, args: string[] = []): Promise<strin
   return new Promise((resolve, reject) => {
     const proc = spawn(command, args, {
       stdio: 'pipe',
-      shell: true
     });
 
     let stdout = '';
@@ -54,7 +53,6 @@ export function execCommandFull(command: string, args: string[] = []): Promise<E
   return new Promise((resolve) => {
     const proc = spawn(command, args, {
       stdio: 'pipe',
-      shell: true
     });
 
     let stdout = '';

package/src/utils/filename.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Tests for filename generation utilities
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateScreenshotFilename } from './filename.js';
+
+describe('generateScreenshotFilename', () => {
+  it('formats UTC timestamp correctly', () => {
+    const date = new Date('2026-01-15T14:30:45Z');
+    expect(generateScreenshotFilename(date))
+      .toBe('screenshot-2026-01-15-14-30-45-Z.jpg');
+  });
+
+  it('pads single digits with zeros', () => {
+    const date = new Date('2026-01-05T08:09:03Z');
+    expect(generateScreenshotFilename(date))
+      .toBe('screenshot-2026-01-05-08-09-03-Z.jpg');
+  });
+
+  it('handles midnight correctly', () => {
+    const date = new Date('2026-12-31T00:00:00Z');
+    expect(generateScreenshotFilename(date))
+      .toBe('screenshot-2026-12-31-00-00-00-Z.jpg');
+  });
+
+  it('generates filename with current time when no date provided', () => {
+    const filename = generateScreenshotFilename();
+
+    // Verify format is correct
+    expect(filename).toMatch(/^screenshot-\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2}-Z\.jpg$/);
+
+    // Extract timestamp from filename
+    const match = filename.match(/^screenshot-(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-Z\.jpg$/);
+    expect(match).not.toBeNull();
+
+    if (match) {
+      const [, year, month, day, hours, minutes, seconds] = match;
+      const filenameDate = new Date(Date.UTC(
+        parseInt(year),
+        parseInt(month) - 1,
+        parseInt(day),
+        parseInt(hours),
+        parseInt(minutes),
+        parseInt(seconds)
+      ));
+
+      // Verify the timestamp is reasonable (within last minute)
+      const now = new Date();
+      const diff = now.getTime() - filenameDate.getTime();
+      expect(diff).toBeGreaterThanOrEqual(0);
+      expect(diff).toBeLessThan(60000); // Within last 60 seconds
+    }
+  });
+});

package/src/utils/filename.ts

@@ -0,0 +1,18 @@
+/**
+ * Filename generation utilities for screenshots
+ */
+
+/**
+ * Generate UTC timestamp filename
+ * Format: screenshot-YYYY-MM-DD-HH-MM-SS-Z.jpg
+ */
+export function generateScreenshotFilename(date: Date = new Date()): string {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(date.getUTCDate()).padStart(2, '0');
+  const hours = String(date.getUTCHours()).padStart(2, '0');
+  const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+  const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+
+  return `screenshot-${year}-${month}-${day}-${hours}-${minutes}-${seconds}-Z.jpg`;
+}

package/tests/adb.test.ts

@@ -28,8 +28,8 @@ describe('isPortListening', () => {
 });
 
 describe('getCDPPort', () => {
-  it('should return the default CDP port', () => {
-    const port = getCDPPort();
+  it('should return the default CDP port', async () => {
+    const port = await getCDPPort();
     expect(port).toBe(9223);
   });
 });

package/tests/exec.test.ts

@@ -8,7 +8,7 @@ describe('execCommand', () => {
   });
 
   it('should reject on non-zero exit code', async () => {
-    await expect(execCommand('sh -c "exit 1"', [])).rejects.toThrow();
+    await expect(execCommand('sh', ['-c', 'exit 1'])).rejects.toThrow();
   });
 
   it('should handle shell commands', async () => {
@@ -25,12 +25,12 @@ describe('execCommandFull', () => {
   });
 
   it('should return non-zero exit code without throwing', async () => {
-    const result = await execCommandFull('sh -c "exit 42"', []);
+    const result = await execCommandFull('sh', ['-c', 'exit 42']);
     expect(result.code).toBe(42);
   });
 
   it('should capture stderr', async () => {
-    const result = await execCommandFull('sh -c "echo error >&2"', []);
+    const result = await execCommandFull('sh', ['-c', 'echo error >&2']);
     expect(result.stderr.trim()).toBe('error');
   });
 });