@myerscarpenter/quest-dev 1.4.1 → 2.0.0

package/src/commands/logcat.ts

@@ -7,12 +7,12 @@
  */
 
 import { resolve, join } from 'path';
-import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, symlinkSync, statSync, readlinkSync, openSync } from 'fs';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, symlinkSync, statSync, readlinkSync, openSync, closeSync } from 'fs';
 import { spawn } from 'child_process';
-import { checkADBPath, checkADBDevices } from '../utils/adb.js';
+import { checkADBPath, checkADBDevices, adbArgs } from '../utils/adb.js';
 import { execCommand, execCommandFull } from '../utils/exec.js';
 
-const LOG_DIR = process.env.LOG_DIR || 'logs/logcat';
+const LOG_DIR = resolve(process.env.LOG_DIR || 'logs/logcat');
 const PID_FILE = join(LOG_DIR, '.logcat_pid');
 const LOGFILE_LINK = join(LOG_DIR, 'latest.txt');
 
@@ -143,7 +143,7 @@ export async function startCommand(filter?: string): Promise<void> {
 
   // Clear the buffer first - critical for Quest
   try {
-    await execCommand('adb', ['logcat', '-c']);
+    await execCommand('adb', adbArgs('logcat', '-c'));
     console.log('Ring buffer cleared.');
   } catch (error) {
     console.error('Failed to clear ring buffer:', (error as Error).message);
@@ -155,7 +155,7 @@ export async function startCommand(filter?: string): Promise<void> {
   }
 
   // Start background logcat process
-  const args = ['logcat', '-v', 'threadtime'];
+  const args = adbArgs('logcat', '-v', 'threadtime');
   if (filter) {
     args.push(filter);
   }
@@ -167,6 +167,7 @@ export async function startCommand(filter?: string): Promise<void> {
     stdio: ['ignore', fd, fd],
     detached: true
   });
+  closeSync(fd); // child process owns the fd now
 
   // Unref so parent can exit immediately
   proc.unref();

package/src/commands/screenshot.ts

@@ -5,9 +5,11 @@
 
 import { resolve, join } from 'path';
 import { existsSync, statSync } from 'fs';
-import { checkADBPath, checkADBDevices, checkUSBFileTransfer, checkQuestAwake } from '../utils/adb.js';
+import { checkADBPath, checkADBDevices, checkUSBFileTransfer, checkQuestAwake, setAdbDevice, adbArgs } from '../utils/adb.js';
 import { execCommand, execCommandFull } from '../utils/exec.js';
+import { loadConfig } from '../utils/config.js';
 import { generateScreenshotFilename } from '../utils/filename.js';
+import { addJpegFileComment } from '../utils/jpeg-comment.js';
 
 /**
  * Validate directory exists and is writable
@@ -36,7 +38,7 @@ function validateDirectory(dirPath: string): void {
  */
 async function triggerScreenshot(): Promise<boolean> {
   try {
-    await execCommand('adb', [
+    await execCommand('adb', adbArgs(
       'shell',
       'am',
       'startservice',
@@ -44,7 +46,7 @@ async function triggerScreenshot(): Promise<boolean> {
       'com.oculus.metacam/.capture.CaptureService',
       '-a',
       'TAKE_SCREENSHOT'
-    ]);
+    ));
     console.log('Screenshot service triggered');
     return true;
   } catch (error) {
@@ -58,7 +60,7 @@ async function triggerScreenshot(): Promise<boolean> {
  */
 async function getMostRecentScreenshot(): Promise<string | null> {
   try {
-    const output = await execCommand('adb', ['shell', 'ls', '-t', '/sdcard/Oculus/Screenshots/']);
+    const output = await execCommand('adb', adbArgs('shell', 'ls', '-t', '/sdcard/Oculus/Screenshots/'));
     const files = output.split('\n').filter(line => line.trim() && line.endsWith('.jpg'));
 
     if (files.length === 0) {
@@ -82,7 +84,7 @@ async function isJpegComplete(filename: string): Promise<boolean> {
     const { spawn } = await import('child_process');
 
     return new Promise((resolve) => {
-      const proc = spawn('adb', ['exec-out', 'tail', '-c', '2', remotePath]);
+      const proc = spawn('adb', adbArgs('exec-out', 'tail', '-c', '2', remotePath));
       const chunks: Buffer[] = [];
 
       proc.stdout.on('data', (chunk: Buffer) => chunks.push(chunk));
@@ -108,7 +110,7 @@ async function isJpegComplete(filename: string): Promise<boolean> {
 async function pullScreenshot(filename: string, outputPath: string): Promise<boolean> {
   try {
     const remotePath = `/sdcard/Oculus/Screenshots/${filename}`;
-    await execCommand('adb', ['pull', remotePath, outputPath]);
+    await execCommand('adb', adbArgs('pull', remotePath, outputPath));
     console.log(`Screenshot saved to: ${outputPath}`);
     return true;
   } catch (error) {
@@ -122,7 +124,7 @@ async function pullScreenshot(filename: string, outputPath: string): Promise<boo
  */
 async function deleteRemoteScreenshot(filename: string): Promise<void> {
   const remotePath = `/sdcard/Oculus/Screenshots/${filename}`;
-  const result = await execCommandFull('adb', ['shell', 'rm', remotePath]);
+  const result = await execCommandFull('adb', adbArgs('shell', 'rm', remotePath));
   if (result.code !== 0) {
     console.warn(`Warning: Failed to delete screenshot from Quest: ${filename}`);
   } else {
@@ -133,11 +135,9 @@ async function deleteRemoteScreenshot(filename: string): Promise<void> {
 /**
  * Add caption to JPEG COM metadata
  */
-async function addJpegMetadata(filePath: string, caption: string): Promise<boolean> {
+function addJpegMetadata(filePath: string, caption: string): boolean {
   try {
-    const { exiftool } = await import('exiftool-vendored');
-    await exiftool.write(filePath, { Comment: caption });
-    await exiftool.end();
+    addJpegFileComment(filePath, caption);
     console.log(`Caption added: "${caption}"`);
     return true;
   } catch (error) {
@@ -158,9 +158,15 @@ export async function screenshotCommand(directoryPath: string, caption: string |
   validateDirectory(resolvedDir);
 
   // Generate filename
-  const localFilename = generateScreenshotFilename();
+  const localFilename = generateScreenshotFilename(new Date(), caption);
   const outputPath = join(resolvedDir, localFilename);
 
+  // Load device config so -s <device> targets the right Quest
+  const config = loadConfig();
+  if (config.device) {
+    setAdbDevice(config.device);
+  }
+
   // Check prerequisites
   checkADBPath();
   await checkADBDevices();
@@ -215,7 +221,7 @@ export async function screenshotCommand(directoryPath: string, caption: string |
 
   // Add metadata (non-fatal, only if caption provided)
   if (caption) {
-    await addJpegMetadata(outputPath, caption);
+    addJpegMetadata(outputPath, caption);
   }
 
   // Delete from Quest after successful pull

package/src/commands/stay-awake.ts

@@ -8,100 +8,29 @@
  * parent is killed (TaskStop, terminal close, claude code exit).
  */
 
-import { checkADBPath, getBatteryInfo, formatBatteryInfo } from '../utils/adb.js';
+import { checkADBPath, getBatteryInfo, formatBatteryInfo, adbArgs } from '../utils/adb.js';
 import { loadPin, loadConfig } from '../utils/config.js';
-import { execCommand, execCommandFull } from '../utils/exec.js';
-import { execSync, spawn, ChildProcess } from 'child_process';
+import { execCommand } from '../utils/exec.js';
+import { execFileSync, spawn, ChildProcess } from 'child_process';
 import * as os from 'os';
 import * as fs from 'fs';
-
-export interface TestProperties {
-  disable_guardian: boolean;
-  disable_dialogs: boolean;
-  disable_autosleep: boolean;
-  set_proximity_close: boolean;
-}
-
-/**
- * Build ADB args for SET_PROPERTY call
- */
-export function buildSetPropertyArgs(pin: string, enabled: boolean): string[] {
-  return [
-    'shell', 'content', 'call',
-    '--uri', 'content://com.oculus.rc',
-    '--method', 'SET_PROPERTY',
-    '--extra', `disable_guardian:b:${enabled}`,
-    '--extra', `disable_dialogs:b:${enabled}`,
-    '--extra', `disable_autosleep:b:${enabled}`,
-    '--extra', `set_proximity_close:b:${enabled}`,
-    '--extra', `PIN:s:${pin}`,
-  ];
-}
-
-/**
- * Parse GET_PROPERTY Bundle output into structured data
- * Input: "Bundle[{disable_guardian=true, set_proximity_close=true, disable_dialogs=true, disable_autosleep=true}]"
- */
-export function parseTestProperties(output: string): TestProperties {
-  const defaults: TestProperties = {
-    disable_guardian: false,
-    disable_dialogs: false,
-    disable_autosleep: false,
-    set_proximity_close: false,
-  };
-
-  const match = output.match(/Bundle\[\{(.+)\}\]/);
-  if (!match) return defaults;
-
-  const pairs = match[1].split(',').map(s => s.trim());
-  for (const pair of pairs) {
-    const [key, value] = pair.split('=');
-    if (key && value && key in defaults) {
-      (defaults as any)[key] = value === 'true';
-    }
-  }
-
-  return defaults;
-}
-
-/**
- * Call SET_PROPERTY to enable or disable test mode
- */
-async function setTestProperties(pin: string, enabled: boolean): Promise<void> {
-  const args = buildSetPropertyArgs(pin, enabled);
-  await execCommand('adb', args);
-}
-
-/**
- * Call GET_PROPERTY and return parsed test properties
- */
-async function getTestProperties(): Promise<TestProperties> {
-  const result = await execCommandFull('adb', [
-    'shell', 'content', 'call',
-    '--uri', 'content://com.oculus.rc',
-    '--method', 'GET_PROPERTY',
-  ]);
-  return parseTestProperties(result.stdout);
-}
-
-/**
- * Format test properties for display
- */
-function formatTestProperties(props: TestProperties): string {
-  const lines = [
-    `  Guardian disabled:  ${props.disable_guardian}`,
-    `  Dialogs disabled:  ${props.disable_dialogs}`,
-    `  Autosleep disabled: ${props.disable_autosleep}`,
-    `  Proximity close:   ${props.set_proximity_close}`,
-  ];
-  return lines.join('\n');
-}
+import {
+  type TestProperties,
+  buildSetPropertyArgs,
+  parseTestProperties,
+  setTestProperties,
+  getTestProperties,
+  formatTestProperties,
+} from '../utils/test-properties.js';
+
+// Re-export for backward compatibility with tests
+export { type TestProperties, buildSetPropertyArgs, parseTestProperties };
 
 /**
  * Wake the Quest screen
  */
 async function wakeScreen(): Promise<void> {
-  await execCommand('adb', ['shell', 'input', 'keyevent', 'KEYCODE_WAKEUP']);
+  await execCommand('adb', adbArgs('shell', 'input', 'keyevent', 'KEYCODE_WAKEUP'));
 }
 
 /**
@@ -121,7 +50,9 @@ export async function stayAwakeDisable(cliPin?: string): Promise<void> {
   checkADBPath();
   const pin = loadPin(cliPin);
   await setTestProperties(pin, false);
-  console.log('Test mode disabled — guardian, dialogs, and autosleep restored');
+  const props = await getTestProperties();
+  console.log('Test mode disabled:');
+  console.log(formatTestProperties(props));
 }
 
 /**
@@ -138,8 +69,8 @@ export async function stayAwakeWatchdog(parentPid: number, pin: string): Promise
       clearInterval(checkParent);
 
       try {
-        const args = buildSetPropertyArgs(pin, false);
-        execSync(`adb ${args.join(' ')}`, { stdio: 'ignore' });
+        const args = adbArgs(...buildSetPropertyArgs(pin, false));
+        execFileSync('adb', args, { stdio: 'ignore' });
 
         const pidFile = `${os.homedir()}/.quest-dev-stay-awake.pid`;
         try { fs.unlinkSync(pidFile); } catch {}
@@ -288,8 +219,8 @@ export async function stayAwakeCommand(
     try {
       try { fs.unlinkSync(pidFilePath); } catch {}
 
-      const args = buildSetPropertyArgs(pin, false);
-      execSync(`adb ${args.join(' ')}`, { stdio: 'ignore' });
+      const args = adbArgs(...buildSetPropertyArgs(pin, false));
+      execFileSync('adb', args, { stdio: 'ignore' });
       console.log('Test mode disabled — guardian, dialogs, and autosleep restored');
     } catch (error) {
       console.error('Failed to restore settings:', (error as Error).message);

package/src/daemon/adbkit-apkreader.d.ts

@@ -0,0 +1,14 @@
+declare module "adbkit-apkreader" {
+  interface Manifest {
+    package: string;
+    versionCode: number;
+    versionName: string;
+  }
+
+  class ApkReader {
+    static open(path: string): Promise<ApkReader>;
+    readManifest(): Promise<Manifest>;
+  }
+
+  export default ApkReader;
+}

package/src/daemon/cast-manager.ts

@@ -0,0 +1,282 @@
+/**
+ * CastManager: lazy-loaded manager for cast sessions within the daemon.
+ * Wraps CastSession with start/stop lifecycle and SSE broadcasting.
+ * Server state is the single source of truth — pushed to clients via SSE.
+ */
+
+import { EventEmitter } from "node:events";
+import type { ServerResponse } from "node:http";
+import { checkADBPath, getAdbDevice } from "../utils/adb.js";
+import { execCommand } from "../utils/exec.js";
+import { verbose } from "../utils/verbose.js";
+import { CastSession } from "../cast/session.js";
+import { ensureCastingInstalled } from "../utils/casting-apk.js";
+import { resolveResolution } from "@myerscarpenter/cast2-protocol";
+
+export interface CastStartOptions {
+  listenPort?: number;
+  resolution?: string;
+  width?: number;
+  height?: number;
+}
+
+function round4(n: number): number {
+  return Math.round(n * 10000) / 10000;
+}
+
+function round1(n: number): number {
+  return Math.round(n * 10) / 10;
+}
+
+function deg(rad: number): number {
+  return (rad * 180) / Math.PI;
+}
+
+export class CastManager extends EventEmitter {
+  private session: CastSession | null = null;
+  private sseClients = new Set<ServerResponse>();
+  private questIp: string | null = null;
+  private configuredDevice: string | undefined;
+  private statsInterval: ReturnType<typeof setInterval> | null = null;
+  private starting = false;
+
+  constructor(device?: string) {
+    super();
+    this.configuredDevice = device;
+  }
+
+  get isActive(): boolean {
+    return this.session !== null && this.session.connected;
+  }
+
+  getSession(): CastSession | null {
+    return this.session;
+  }
+
+  /** Build full status snapshot from current session state. */
+  getStatus(): Record<string, unknown> {
+    const session = this.session;
+    if (!session) {
+      return { connected: false, running: false };
+    }
+    const p = session.pose;
+    return {
+      connected: session.connected,
+      running: session.running,
+      width: session.width,
+      height: session.height,
+      frame_count: session.frameCount,
+      bytes: session.byteCount,
+      fps: session.fps,
+      elapsed: session.elapsedSeconds,
+      has_frame: session.getScreenshot() !== null,
+      eye: session.eye === 0 ? "right" : session.eye === 2 ? "stereo" : "left",
+      pose_loop: session.poseLoopActive,
+      pose: {
+        x: round4(p.x),
+        y: round4(p.y),
+        z: round4(p.z),
+        yaw: round4(p.yaw),
+        pitch: round4(p.pitch),
+        yaw_deg: round1(deg(p.yaw)),
+        pitch_deg: round1(deg(p.pitch)),
+      },
+    };
+  }
+
+  async start(opts: CastStartOptions = {}): Promise<void> {
+    if (this.session?.connected) {
+      return; // Already active
+    }
+    if (this.starting) {
+      throw new Error("Cast start already in progress");
+    }
+    this.starting = true;
+
+    try {
+      // Stop any lingering session
+      if (this.session) {
+        await this.stopSession();
+      }
+
+      checkADBPath();
+
+      // Check for connected devices
+      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) {
+        throw new Error("No ADB devices connected");
+      }
+
+      // Get Quest IP
+      const questIp = await this.getQuestIp();
+      this.questIp = questIp;
+
+      // Ensure casting service APK is installed on Quest
+      // Use the ADB device serial (USB or configured), not the WiFi IP
+      const adbDevice = getAdbDevice() ?? await this.getAdbSerial() ?? `${questIp}:5555`;
+      await ensureCastingInstalled(adbDevice);
+
+      const listenPort = opts.listenPort ?? 4445;
+      const { width, height } = resolveResolution(opts.resolution, opts.width, opts.height);
+
+      // Create and start session
+      const session = new CastSession({ listenPort, width, height });
+      this.session = session;
+
+      // Wire session events → SSE broadcast
+      session.on("connected", () => this.broadcastStatus());
+      session.on("disconnected", () => this.broadcastStatus());
+      session.on("pose-loop", () => this.broadcastStatus());
+
+      // Complete all async setup before starting periodic work
+      await session.bind();
+      if (session.listenPort !== listenPort) {
+        verbose(
+          `Port ${listenPort} in use, listening on ${session.listenPort}`,
+        );
+      }
+      await session.adbSetup(questIp);
+      await session.start(questIp);
+
+      // Stats interval created AFTER all async ops succeed
+      this.statsInterval = setInterval(() => {
+        if (session.connected) {
+          this.broadcastStatus();
+        }
+      }, 500);
+
+      verbose("Quest connected, casting active");
+    } finally {
+      this.starting = false;
+    }
+  }
+
+  async stop(): Promise<void> {
+    await this.stopSession();
+    this.broadcastStatus();
+  }
+
+  async restart(): Promise<void> {
+    if (!this.session) {
+      await this.start();
+      return;
+    }
+    this.broadcastToast("Restarting cast\u2026");
+    await this.session.restart();
+  }
+
+  private async stopSession(): Promise<void> {
+    if (this.statsInterval) {
+      clearInterval(this.statsInterval);
+      this.statsInterval = null;
+    }
+    if (this.session) {
+      try {
+        await this.session.stop();
+      } catch {
+        // Best effort
+      }
+      this.session = null;
+    }
+  }
+
+  /** Get the first connected ADB device serial (e.g. USB serial or IP:port) */
+  private async getAdbSerial(): Promise<string | null> {
+    const output = await execCommand("adb", ["devices"]);
+    const lines = output.trim().split("\n").slice(1);
+    const first = lines.find((l) => l.includes("device"));
+    if (!first) return null;
+    return first.split("\t")[0].trim();
+  }
+
+  private async getQuestIp(): Promise<string> {
+    // If a device IP was configured, use it directly (strip :port if present)
+    if (this.configuredDevice) {
+      const ip = this.configuredDevice.split(":")[0];
+      verbose(`Using configured device: ${ip}`);
+      return ip;
+    }
+
+    const devOutput = await execCommand("adb", ["devices"]);
+    const devLines = devOutput.trim().split("\n").slice(1);
+    const firstDevice = devLines.find((l) => l.includes("device"));
+    if (!firstDevice) {
+      throw new Error("No authorized ADB device found");
+    }
+    const deviceId = firstDevice.split("\t")[0].trim();
+    try {
+      const ip = await execCommand("adb", [
+        "-s",
+        deviceId,
+        "shell",
+        "ip addr show wlan0 | grep 'inet ' | tr -s ' ' | cut -f3 -d' ' | cut -f1 -d/",
+      ]);
+      const trimmed = ip.trim();
+      if (trimmed && !trimmed.includes("error")) {
+        return trimmed;
+      }
+    } catch {
+      // Fallback
+    }
+    return deviceId.split(":")[0];
+  }
+
+  // --- SSE ---
+
+  broadcast(event: string, data: unknown): void {
+    const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const res of this.sseClients) {
+      try {
+        res.write(msg);
+      } catch {
+        this.sseClients.delete(res);
+      }
+    }
+  }
+
+  /** Broadcast full status snapshot as SSE "status" event. */
+  broadcastStatus(): void {
+    this.broadcast("status", this.getStatus());
+  }
+
+  broadcastToast(msg: string): void {
+    this.broadcast("toast", { message: msg });
+  }
+
+  addSSEClient(res: ServerResponse): void {
+    this.sseClients.add(res);
+  }
+
+  removeSSEClient(res: ServerResponse): void {
+    this.sseClients.delete(res);
+  }
+
+  // --- Cleanup ---
+
+  cleanup(): void {
+    if (this.statsInterval) {
+      clearInterval(this.statsInterval);
+      this.statsInterval = null;
+    }
+    if (this.session) {
+      try {
+        this.session.stop();
+      } catch {
+        // Best effort sync cleanup
+      }
+      this.session = null;
+    }
+    for (const res of this.sseClients) {
+      try {
+        res.end();
+      } catch {
+        // Ignore
+      }
+    }
+    this.sseClients.clear();
+  }
+}