@myerscarpenter/quest-dev 1.4.1 → 2.0.0

package/tests/cast/decoder.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { extractJpegFrames } from "../../src/cast/decoder.js";
+
+describe("extractJpegFrames", () => {
+  const SOI = Buffer.from([0xff, 0xd8]);
+  const EOI = Buffer.from([0xff, 0xd9]);
+
+  function makeJpeg(bodySize: number): Buffer {
+    const body = Buffer.alloc(bodySize, 0x42);
+    return Buffer.concat([SOI, body, EOI]);
+  }
+
+  it("returns no frames from empty buffer", () => {
+    const result = extractJpegFrames(Buffer.alloc(0));
+    expect(result.frames).toHaveLength(0);
+    expect(result.remainder.length).toBe(0);
+  });
+
+  it("returns no frames from buffer without markers", () => {
+    const result = extractJpegFrames(Buffer.alloc(100, 0x42));
+    expect(result.frames).toHaveLength(0);
+    expect(result.remainder.length).toBe(0);
+  });
+
+  it("extracts a single complete JPEG frame", () => {
+    const jpeg = makeJpeg(10);
+    const result = extractJpegFrames(jpeg);
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]).toEqual(jpeg);
+    expect(result.remainder.length).toBe(0);
+  });
+
+  it("extracts multiple JPEG frames", () => {
+    const j1 = makeJpeg(5);
+    const j2 = makeJpeg(8);
+    const buf = Buffer.concat([j1, j2]);
+    const result = extractJpegFrames(buf);
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]).toEqual(j1);
+    expect(result.frames[1]).toEqual(j2);
+    expect(result.remainder.length).toBe(0);
+  });
+
+  it("handles partial frame (SOI without EOI)", () => {
+    const partial = Buffer.concat([SOI, Buffer.alloc(10, 0x42)]);
+    const result = extractJpegFrames(partial);
+    expect(result.frames).toHaveLength(0);
+    expect(result.remainder).toEqual(partial);
+  });
+
+  it("extracts complete frame and keeps partial remainder", () => {
+    const complete = makeJpeg(5);
+    const partial = Buffer.concat([SOI, Buffer.alloc(3, 0x42)]);
+    const buf = Buffer.concat([complete, partial]);
+    const result = extractJpegFrames(buf);
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]).toEqual(complete);
+    expect(result.remainder).toEqual(partial);
+  });
+
+  it("skips garbage before SOI", () => {
+    const garbage = Buffer.alloc(20, 0xab);
+    const jpeg = makeJpeg(5);
+    const buf = Buffer.concat([garbage, jpeg]);
+    const result = extractJpegFrames(buf);
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]).toEqual(jpeg);
+  });
+
+  it("handles zero-length body JPEG", () => {
+    const jpeg = Buffer.concat([SOI, EOI]);
+    const result = extractJpegFrames(jpeg);
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]).toEqual(jpeg);
+  });
+
+  it("handles buffer that is just SOI", () => {
+    const result = extractJpegFrames(SOI);
+    expect(result.frames).toHaveLength(0);
+    expect(result.remainder).toEqual(SOI);
+  });
+});

package/tests/cast/session-restart.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { createServer, type Server, type Socket } from "node:net";
+
+/**
+ * Bug: session.restart() calls stop() which closes the TCP server,
+ * then calls start() which expects the server to be listening.
+ * The server must be re-bound (listen again) after close.
+ *
+ * We test the core invariant: after restart(), the server is listening.
+ */
+
+describe("TCP server re-bind after close", () => {
+  let server: Server;
+  let port: number;
+
+  beforeEach(async () => {
+    server = createServer();
+    // Bind to random port
+    await new Promise<void>((resolve) => {
+      server.listen(0, "127.0.0.1", () => resolve());
+    });
+    port = (server.address() as { port: number }).port;
+  });
+
+  it("closed server does not accept connections", async () => {
+    server.close();
+    // Wait for close to complete
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Try to connect — should fail
+    const result = await new Promise<string>((resolve) => {
+      const sock = new (require("node:net").Socket)();
+      sock.on("error", () => resolve("refused"));
+      sock.on("connect", () => { sock.destroy(); resolve("connected"); });
+      sock.connect(port, "127.0.0.1");
+    });
+    expect(result).toBe("refused");
+  });
+
+  it("server can re-listen after close", async () => {
+    // Close then re-listen on same port
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await new Promise<void>((resolve, reject) => {
+      server.listen(port, "127.0.0.1", () => resolve());
+      server.on("error", reject);
+    });
+
+    // Should accept connections again
+    const result = await new Promise<string>((resolve) => {
+      const sock = new (require("node:net").Socket)();
+      sock.on("error", () => resolve("refused"));
+      sock.on("connect", () => { sock.destroy(); resolve("connected"); });
+      sock.connect(port, "127.0.0.1");
+    });
+    expect(result).toBe("connected");
+    server.close();
+  });
+});
+
+describe("connection count guard", () => {
+  it("should only process exactly 2 connections", () => {
+    const sockets: string[] = [];
+    let controlSocket: string | null = null;
+    let videoSocket: string | null = null;
+    let assignCount = 0;
+
+    // Simulates fixed connection handler using === 2
+    function onConnection(id: string) {
+      sockets.push(id);
+      if (sockets.length === 2) {
+        controlSocket = sockets[0];
+        videoSocket = sockets[1];
+        assignCount++;
+      }
+    }
+
+    onConnection("sock-a");
+    onConnection("sock-b");
+    onConnection("sock-c"); // spurious 3rd connection
+
+    expect(assignCount).toBe(1); // assigned exactly once
+    expect(controlSocket).toBe("sock-a");
+    expect(videoSocket).toBe("sock-b");
+  });
+
+  it("bug: >= 2 fires on every subsequent connection", () => {
+    const sockets: string[] = [];
+    let videoSocket: string | null = null;
+    let assignCount = 0;
+
+    // Old buggy handler using >= 2
+    function onConnection(id: string) {
+      sockets.push(id);
+      if (sockets.length >= 2) {
+        videoSocket = sockets[1];
+        assignCount++;
+      }
+    }
+
+    onConnection("sock-a");
+    onConnection("sock-b");
+    onConnection("sock-c"); // spurious 3rd
+
+    expect(assignCount).toBe(2); // BUG: assigned twice
+    expect(videoSocket).toBe("sock-b"); // at least video isn't overwritten to sock-c since sockets[1] is stable
+  });
+});

package/tests/config.test.ts

@@ -11,7 +11,7 @@ beforeEach(() => {
 });
 
 describe('loadConfig', () => {
-  it('returns empty object when no config files exist', () => {
+  it('returns empty object when no config file exists', () => {
     mockReadFileSync.mockImplementation(() => {
       throw new Error('ENOENT');
     });
@@ -20,31 +20,32 @@ describe('loadConfig', () => {
     expect(config).toEqual({});
   });
 
-  it('reads .quest-dev.json from cwd when present', () => {
+  it('reads ~/.config/quest-dev/config.json', () => {
     mockReadFileSync.mockImplementation((path) => {
-      if (String(path).endsWith('.quest-dev.json')) {
-        return JSON.stringify({ pin: '1234' });
+      if (String(path).endsWith('config.json')) {
+        return JSON.stringify({ pin: '1234', port: 8091 });
       }
       throw new Error('ENOENT');
     });
 
     const config = loadConfig();
     expect(config.pin).toBe('1234');
+    expect(config.port).toBe(8091);
   });
 
-  it('merges configs: local file wins over global file', () => {
-    mockReadFileSync.mockImplementation((path) => {
-      if (String(path).endsWith('.quest-dev.json')) {
-        return JSON.stringify({ pin: 'local-pin', idleTimeout: 5000 });
-      }
-      if (String(path).endsWith('config.json')) {
-        return JSON.stringify({ pin: 'global-pin', lowBattery: 15 });
-      }
-      throw new Error('ENOENT');
-    });
+  it('returns all config fields', () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      pin: 'test-pin',
+      port: 9000,
+      device: '192.168.1.100',
+      idleTimeout: 5000,
+      lowBattery: 15,
+    }));
 
     const config = loadConfig();
-    expect(config.pin).toBe('local-pin');
+    expect(config.pin).toBe('test-pin');
+    expect(config.port).toBe(9000);
+    expect(config.device).toBe('192.168.1.100');
     expect(config.idleTimeout).toBe(5000);
     expect(config.lowBattery).toBe(15);
   });
@@ -52,18 +53,12 @@ describe('loadConfig', () => {
 
 describe('loadPin', () => {
   it('returns CLI pin when provided', () => {
-    // Should not even read config files
     const pin = loadPin('cli-pin');
     expect(pin).toBe('cli-pin');
   });
 
   it('falls back to config file pin', () => {
-    mockReadFileSync.mockImplementation((path) => {
-      if (String(path).endsWith('.quest-dev.json')) {
-        return JSON.stringify({ pin: 'config-pin' });
-      }
-      throw new Error('ENOENT');
-    });
+    mockReadFileSync.mockReturnValue(JSON.stringify({ pin: 'config-pin' }));
 
     const pin = loadPin();
     expect(pin).toBe('config-pin');

package/tests/daemon/api-status.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from "vitest";
+
+/**
+ * Bug: Dashboard api() helper doesn't check HTTP status codes.
+ * A 500 response with HTML body would throw an uncaught JSON parse error.
+ * Fix: check response.ok before parsing JSON.
+ */
+
+/** Fixed api helper that checks HTTP status. */
+async function apiFetch(
+  fetcher: typeof fetch,
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<unknown> {
+  const opts: RequestInit = { method };
+  if (body) {
+    opts.headers = { "Content-Type": "application/json" };
+    opts.body = JSON.stringify(body);
+  }
+  const r = await fetcher(path, opts);
+  if (!r.ok) {
+    // Try to parse JSON error, fall back to status text
+    let msg: string;
+    try {
+      const json = await r.json();
+      msg = json.error ?? r.statusText;
+    } catch {
+      msg = r.statusText;
+    }
+    throw new Error(`HTTP ${r.status}: ${msg}`);
+  }
+  return r.json();
+}
+
+function mockFetch(status: number, body: unknown, contentType = "application/json"): typeof fetch {
+  return vi.fn().mockResolvedValue({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 500 ? "Internal Server Error" : "OK",
+    json: () => Promise.resolve(body),
+    headers: new Headers({ "content-type": contentType }),
+  }) as unknown as typeof fetch;
+}
+
+describe("api fetch with status checking", () => {
+  it("returns JSON on 200", async () => {
+    const f = mockFetch(200, { ok: true });
+    const result = await apiFetch(f, "GET", "/status");
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("throws on 500 with JSON error body", async () => {
+    const f = mockFetch(500, { error: "something broke" });
+    await expect(apiFetch(f, "POST", "/cast/start")).rejects.toThrow(
+      "HTTP 500: something broke",
+    );
+  });
+
+  it("throws on 503 with fallback to statusText", async () => {
+    const f = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 503,
+      statusText: "Service Unavailable",
+      json: () => Promise.reject(new Error("not json")),
+    }) as unknown as typeof fetch;
+
+    await expect(apiFetch(f, "GET", "/cast/screenshot")).rejects.toThrow(
+      "HTTP 503: Service Unavailable",
+    );
+  });
+
+  it("passes body correctly", async () => {
+    const f = mockFetch(200, { ok: true });
+    await apiFetch(f, "POST", "/cast/pose", { dz: 0.3 });
+    expect(f).toHaveBeenCalledWith("/cast/pose", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: '{"dz":0.3}',
+    });
+  });
+});

package/tests/daemon/cast-manager.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ServerResponse } from "node:http";
+
+/**
+ * Minimal extraction of CastManager.broadcast() logic for unit testing
+ * without needing to instantiate the full CastManager (which requires ADB).
+ */
+function broadcast(
+  sseClients: Set<ServerResponse>,
+  event: string,
+  data: unknown,
+): void {
+  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of sseClients) {
+    try {
+      res.write(msg);
+    } catch {
+      sseClients.delete(res);
+    }
+  }
+}
+
+function makeFakeRes(opts?: { throwOnWrite?: boolean }): ServerResponse {
+  return {
+    write: opts?.throwOnWrite
+      ? () => { throw new Error("socket destroyed"); }
+      : vi.fn(),
+  } as unknown as ServerResponse;
+}
+
+describe("SSE broadcast", () => {
+  it("writes to all live clients", () => {
+    const clients = new Set<ServerResponse>();
+    const a = makeFakeRes();
+    const b = makeFakeRes();
+    clients.add(a);
+    clients.add(b);
+
+    broadcast(clients, "status", { ok: true });
+
+    expect(a.write).toHaveBeenCalledOnce();
+    expect(b.write).toHaveBeenCalledOnce();
+    expect(clients.size).toBe(2);
+  });
+
+  it("removes dead clients on write error", () => {
+    const clients = new Set<ServerResponse>();
+    const alive = makeFakeRes();
+    const dead = makeFakeRes({ throwOnWrite: true });
+    clients.add(alive);
+    clients.add(dead);
+
+    broadcast(clients, "status", { ok: true });
+
+    expect(alive.write).toHaveBeenCalledOnce();
+    expect(clients.size).toBe(1);
+    expect(clients.has(alive)).toBe(true);
+    expect(clients.has(dead)).toBe(false);
+  });
+
+  it("handles all clients dead", () => {
+    const clients = new Set<ServerResponse>();
+    clients.add(makeFakeRes({ throwOnWrite: true }));
+    clients.add(makeFakeRes({ throwOnWrite: true }));
+
+    expect(() => broadcast(clients, "status", {})).not.toThrow();
+    expect(clients.size).toBe(0);
+  });
+});

package/tests/daemon/mjpeg-stream.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+/**
+ * MJPEG stream cleanup logic.
+ * Bug: interval can fire after reply.raw.end() if session stops
+ * and client hasn't disconnected yet.
+ */
+
+interface FakeResponse {
+  writeHead: ReturnType<typeof vi.fn>;
+  write: ReturnType<typeof vi.fn>;
+  end: ReturnType<typeof vi.fn>;
+  ended: boolean;
+}
+
+function createFakeResponse(): FakeResponse {
+  const res: FakeResponse = {
+    writeHead: vi.fn(),
+    write: vi.fn(),
+    end: vi.fn(() => { res.ended = true; }),
+    ended: false,
+  };
+  return res;
+}
+
+/**
+ * Fixed MJPEG stream loop: checks `ended` before writing,
+ * and wraps writes in try-catch.
+ */
+function startMjpegStream(
+  res: FakeResponse,
+  getSession: () => { running: boolean; getScreenshot: () => Buffer | null } | null,
+  onCleanup: () => void,
+): { interval: ReturnType<typeof setInterval>; cleanup: () => void } {
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    clearInterval(interval);
+    try { res.end(); } catch { /* ignore */ }
+    onCleanup();
+  };
+
+  const interval = setInterval(() => {
+    const s = getSession();
+    if (!s?.running) {
+      cleanup();
+      return;
+    }
+    if (res.ended) {
+      cleanup();
+      return;
+    }
+    const jpeg = s.getScreenshot();
+    if (jpeg) {
+      try {
+        res.write(`--frame\r\nContent-Type: image/jpeg\r\nContent-Length: ${jpeg.length}\r\n\r\n`);
+        res.write(jpeg);
+        res.write("\r\n");
+      } catch {
+        cleanup();
+      }
+    }
+  }, 50);
+
+  return { interval, cleanup };
+}
+
+describe("MJPEG stream cleanup", () => {
+  beforeEach(() => { vi.useFakeTimers(); });
+  afterEach(() => { vi.useRealTimers(); });
+
+  it("writes frames while session is running", () => {
+    const res = createFakeResponse();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xd9]);
+    const session = { running: true, getScreenshot: () => jpeg };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(100);
+
+    expect(res.write).toHaveBeenCalled();
+    expect(cleanupFn).not.toHaveBeenCalled();
+  });
+
+  it("cleans up when session stops", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(50);
+
+    session.running = false;
+    vi.advanceTimersByTime(100);
+
+    expect(res.end).toHaveBeenCalled();
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+
+  it("does not write after cleanup", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    const { cleanup } = startMjpegStream(res, () => session, cleanupFn);
+
+    // Simulate client disconnect
+    cleanup();
+    res.write.mockClear();
+
+    vi.advanceTimersByTime(200);
+
+    // No more writes after cleanup
+    expect(res.write).not.toHaveBeenCalled();
+  });
+
+  it("cleanup is idempotent", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    const { cleanup } = startMjpegStream(res, () => session, cleanupFn);
+
+    cleanup();
+    cleanup();
+    cleanup();
+
+    expect(res.end).toHaveBeenCalledOnce();
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+
+  it("handles write errors gracefully", () => {
+    const res = createFakeResponse();
+    res.write.mockImplementation(() => { throw new Error("broken pipe"); });
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(100);
+
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+});

package/tests/daemon/pose-endpoint.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { createPoseState, updatePose, setPoseOffset, type PoseState } from "@myerscarpenter/cast2-protocol";
+
+/**
+ * Simulates the /cast/pose endpoint logic:
+ * offset and delta should be mutually exclusive.
+ */
+function applyPoseRequest(
+  state: PoseState,
+  data: Record<string, number>,
+): PoseState {
+  // Direct offset — takes priority
+  if ("x" in data || "y" in data || "z" in data || "yaw" in data || "pitch" in data) {
+    return setPoseOffset(state, {
+      x: data.x,
+      y: data.y,
+      z: data.z,
+      yaw: data.yaw,
+      pitch: data.pitch,
+    });
+  }
+  // Incremental deltas — only if no offset fields present
+  if ("dx" in data || "dy" in data || "dz" in data || "d_yaw" in data || "d_pitch" in data) {
+    return updatePose(state, {
+      dForward: data.dz ?? 0,
+      dStrafe: data.dx ?? 0,
+      dUp: data.dy ?? 0,
+      dYaw: data.d_yaw ?? 0,
+      dPitch: data.d_pitch ?? 0,
+    });
+  }
+  return state;
+}
+
+describe("/cast/pose endpoint logic", () => {
+  it("applies offset when offset fields provided", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { x: 1.0, y: 2.0 });
+    expect(result.x).toBeCloseTo(1.0);
+    expect(result.y).toBeCloseTo(2.0);
+  });
+
+  it("applies delta when delta fields provided", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { dz: 0.3 }); // forward
+    expect(result.z).toBeCloseTo(-0.3); // OpenXR: forward = -Z
+  });
+
+  it("does not double-apply when both offset and delta provided", () => {
+    const state = createPoseState();
+    // If both are present, offset wins — delta is NOT also applied
+    const result = applyPoseRequest(state, { x: 1.0, dz: 0.3 });
+    expect(result.x).toBeCloseTo(1.0);
+    // z should be 0 (offset only set x, delta was ignored)
+    expect(result.z).toBeCloseTo(0);
+  });
+
+  it("returns unchanged state when no recognized fields", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { foo: 42 } as any);
+    expect(result).toBe(state);
+  });
+});