pixelremotecontrol 0.1.0 → 0.2.0

package/README.md

@@ -22,6 +22,22 @@ If an older manual installation is still on `PATH`, check which launcher wins
 with `Get-Command pixelremotecontrol -All`. Move the old launcher out of `PATH`
 so the npm `.cmd` is selected.
 
+On an Apple Silicon or Intel Mac:
+
+```sh
+npm install -g pixelremotecontrol
+pixelremotecontrol setup --host YOUR_RELAY_TAILSCALE_IP --user YOUR_SSH_USERNAME
+pixelremotecontrol control local pixel8
+```
+
+Mac `setup` downloads the official macOS scrcpy bundle for the Mac's processor,
+verifies its SHA-256 checksum, and caches its `scrcpy` and `adb` executables.
+The Mac needs an SSH client and Tailscale access to the relay. SSH prompts for
+authentication when needed; this package does not save an SSH password.
+`pixelremotecontrol status local pixel8`, `wake`, `lock`, and `restart` also
+work from the Mac. `control asml pixel8` must be run in ASML's interactive
+Windows desktop to put the window there.
+
 In Termux on the configured Pixel:
 
 ```sh
@@ -51,5 +67,14 @@ phone's key can use. This package cannot complete Tailscale sign-in or
 Android's first-time ADB pairing for you.
 
 `pixelremotecontrol wake local pixel8`, `lock`, `restart`, and `status` work on
-the Windows viewer. `control asml pixel8` opens a window on the ASML desktop
+Windows and macOS viewers. `control asml pixel8` opens a window on the ASML desktop
 when run there. The current relay scripts support one configured Pixel 8.
+
+The mirror can show and control ordinary Android screens, including Settings
+and the lock screen, while Android, Wireless debugging, and the phone's Termux
+relay stay active. Enter the phone's passcode in the scrcpy window when Android
+allows input there; the package does not know or bypass it. Some protected
+screens may be blank. After a reboot, a person must perform the first local
+unlock and restart the Termux service. The bootloader and fastboot screens do
+not run Android or scrcpy, so they require a separate USB host and an external
+way to see the physical display.

package/bin/pixelremotecontrol.js

@@ -22,14 +22,17 @@ function usage() {
     'Usage:\n' +
     '  pixelremotecontrol setup [--host RELAY_HOST --user SSH_USER]\n' +
     '  pixelremotecontrol startservice pixel8 asml [CONNECT_PORT]   (Termux on Pixel)\n' +
-    '  pixelremotecontrol control local pixel8 [options]         (Windows viewer)\n' +
+    '  pixelremotecontrol control local pixel8 [options]         (Windows or Mac viewer)\n' +
     '  pixelremotecontrol control asml pixel8                     (ASML desktop)\n' +
     '  pixelremotecontrol <wake|lock|restart|status> local pixel8\n' +
-    '\nRun setup once on each Windows viewer to save its relay address.\n'
+    '\nRun setup once on each Windows or Mac viewer to save its relay address.\n'
   );
 }
 
 function viewerConfigPath() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'PixelRemoteControl', 'config.json');
+  }
   const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
   return path.join(localAppData, 'PixelRemoteControl', 'config.json');
 }
@@ -223,7 +226,17 @@ async function main() {
       process.stdout.write(`Viewer tools ready: ${tools.scrcpyPath}\n`);
       return 0;
     }
-    throw new Error('This package currently supports Windows viewers and Termux on Android.');
+    if (process.platform === 'darwin') {
+      await setupViewerConfig(args.slice(1));
+      if (!commandExists('ssh')) {
+        throw new Error('OpenSSH is required. Install the macOS Command Line Tools, then retry setup.');
+      }
+      const { ensureMacScrcpy } = require('../lib/mac-dependencies.js');
+      const tools = await ensureMacScrcpy();
+      process.stdout.write(`Viewer tools ready: ${tools.scrcpyPath}\n`);
+      return 0;
+    }
+    throw new Error('This package supports Windows or Mac viewers and Termux on Android.');
   }
 
   if (action === 'startservice') {
@@ -235,8 +248,18 @@ async function main() {
   }
 
   if (actions.has(action)) {
+    if (process.platform === 'darwin') {
+      const display = args[1] || 'local';
+      if (action === 'control' && display.toLowerCase() === 'asml') {
+        throw new Error('ASML screen mode needs an interactive Windows desktop session on ASML. Use "control local pixel8" on this Mac, or open an ASML desktop through Remote Desktop.');
+      }
+      const { runMacAction } = require('../lib/mac-viewer.js');
+      return runMacAction(action, display, args[2] || 'pixel8', [
+        ...args.slice(3), ...viewerRelayArgs(args),
+      ]);
+    }
     if (process.platform !== 'win32') {
-      throw new Error('Run screen control on a Windows viewer or ASML desktop.');
+      throw new Error('Run screen control on a Windows or Mac viewer, or on the ASML desktop.');
     }
     const script = path.join(assets, 'viewer', 'pixelremotecontrol-core.ps1');
     const powershellArgs = [

package/lib/mac-dependencies.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const fs = require('node:fs');
+const fsp = fs.promises;
+const path = require('node:path');
+const os = require('node:os');
+const https = require('node:https');
+const crypto = require('node:crypto');
+const { Transform } = require('node:stream');
+const { pipeline } = require('node:stream/promises');
+const { spawnSync } = require('node:child_process');
+
+// These checksums are published in scrcpy's official macOS installation guide.
+// The official release archives include both scrcpy and adb.
+const VERSION = '5.0.1';
+const ARCHIVES = Object.freeze({
+  arm64: Object.freeze({
+    name: `scrcpy-macos-aarch64-v${VERSION}`,
+    sha256: '33611e51977a8289e2e124b220f727895181ef2eb9060e0987a4dc2db9cf0d6b',
+  }),
+  x64: Object.freeze({
+    name: `scrcpy-macos-x86_64-v${VERSION}`,
+    sha256: '31a5467a9e907f162b093267cbbab1276b15c6e709c2ea8159566a8d165beb50',
+  }),
+});
+
+const MAX_DOWNLOAD_BYTES = 250 * 1024 * 1024;
+const MAX_REDIRECTS = 6;
+
+function cacheRoot() {
+  return process.env.PIXELREMOTECONTROL_CACHE_DIR
+    ? path.resolve(process.env.PIXELREMOTECONTROL_CACHE_DIR)
+    : path.join(os.homedir(), 'Library', 'Caches', 'PixelRemoteControl', 'tools');
+}
+
+function isContainedChild(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+
+async function existingBundle(dir) {
+  const scrcpyPath = path.join(dir, 'scrcpy');
+  const adbPath = path.join(dir, 'adb');
+  try {
+    const [scrcpy, adb] = await Promise.all([fsp.stat(scrcpyPath), fsp.stat(adbPath)]);
+    if (!scrcpy.isFile() || !adb.isFile()) return null;
+    await Promise.all([fsp.access(scrcpyPath, fs.constants.X_OK), fsp.access(adbPath, fs.constants.X_OK)]);
+    return { scrcpyPath, adbPath };
+  } catch (error) {
+    if (['ENOENT', 'EACCES', 'EPERM'].includes(error.code)) return null;
+    throw error;
+  }
+}
+
+function download(url, destination, expectedSha256, redirects = 0) {
+  if (redirects > MAX_REDIRECTS) {
+    return Promise.reject(new Error('Too many redirects while downloading scrcpy.'));
+  }
+  if (new URL(url).protocol !== 'https:') {
+    return Promise.reject(new Error('The scrcpy download must use HTTPS.'));
+  }
+
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, {
+      headers: { 'User-Agent': `pixelremotecontrol/${VERSION}` },
+      timeout: 30000,
+    }, async (response) => {
+      try {
+        if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+          const location = response.headers.location;
+          response.resume();
+          if (!location) throw new Error('The scrcpy download redirect had no destination.');
+          await download(new URL(location, url).toString(), destination, expectedSha256, redirects + 1);
+          resolve();
+          return;
+        }
+        if (response.statusCode !== 200) {
+          response.resume();
+          throw new Error(`The scrcpy download failed (HTTP ${response.statusCode}).`);
+        }
+        const length = Number(response.headers['content-length']);
+        if (Number.isFinite(length) && length > MAX_DOWNLOAD_BYTES) {
+          response.resume();
+          throw new Error('The scrcpy archive exceeds the download size limit.');
+        }
+
+        const hash = crypto.createHash('sha256');
+        let bytes = 0;
+        const meter = new Transform({
+          transform(chunk, _encoding, callback) {
+            bytes += chunk.length;
+            if (bytes > MAX_DOWNLOAD_BYTES) {
+              callback(new Error('The scrcpy archive exceeds the download size limit.'));
+              return;
+            }
+            hash.update(chunk);
+            callback(null, chunk);
+          },
+        });
+        await pipeline(response, meter, fs.createWriteStream(destination, { flags: 'wx' }));
+        if (hash.digest('hex') !== expectedSha256) {
+          throw new Error('The scrcpy archive failed SHA-256 verification.');
+        }
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+    request.on('timeout', () => request.destroy(new Error('The scrcpy download timed out.')));
+    request.on('error', reject);
+  });
+}
+
+async function ensureMacScrcpy() {
+  if (process.platform !== 'darwin') {
+    throw new Error('macOS scrcpy installation is available only on macOS.');
+  }
+  const archive = ARCHIVES[process.arch];
+  if (!archive) {
+    throw new Error(`Unsupported macOS architecture: ${process.arch}.`);
+  }
+
+  const explicitScrcpy = process.env.PIXELREMOTECONTROL_SCRCPY;
+  if (explicitScrcpy && process.env.PIXELREMOTECONTROL_FORCE_DOWNLOAD !== '1') {
+    const executable = path.resolve(explicitScrcpy);
+    const bundle = await existingBundle(path.dirname(executable));
+    if (!bundle || bundle.scrcpyPath !== executable) {
+      throw new Error('PIXELREMOTECONTROL_SCRCPY must point to an executable scrcpy with an executable adb beside it.');
+    }
+    return bundle;
+  }
+
+  const root = cacheRoot();
+  const finalDir = path.join(root, archive.name);
+  const cached = await existingBundle(finalDir);
+  if (cached) return cached;
+
+  await fsp.mkdir(root, { recursive: true });
+  const stage = await fsp.mkdtemp(path.join(root, '.scrcpy-stage-'));
+  try {
+    const archivePath = path.join(stage, `${archive.name}.tar.gz`);
+    const extractedRoot = path.join(stage, 'extracted');
+    await fsp.mkdir(extractedRoot);
+    const url = `https://github.com/Genymobile/scrcpy/releases/download/v${VERSION}/${archive.name}.tar.gz`;
+    process.stderr.write(`Downloading scrcpy ${VERSION} for macOS ${process.arch}...\n`);
+    await download(url, archivePath, archive.sha256);
+
+    const extraction = spawnSync('/usr/bin/tar', ['-xzf', archivePath, '-C', extractedRoot], {
+      encoding: 'utf8',
+      maxBuffer: 2 * 1024 * 1024,
+    });
+    if (extraction.error) throw extraction.error;
+    if (extraction.status !== 0) {
+      throw new Error(`Could not extract scrcpy: ${(extraction.stderr || '').trim() || `tar exited ${extraction.status}`}`);
+    }
+
+    const extractedDir = path.join(extractedRoot, archive.name);
+    await Promise.all([
+      fsp.chmod(path.join(extractedDir, 'scrcpy'), 0o755),
+      fsp.chmod(path.join(extractedDir, 'adb'), 0o755),
+    ]);
+    if (!await existingBundle(extractedDir)) {
+      throw new Error('The verified scrcpy archive did not contain scrcpy and adb.');
+    }
+
+    try {
+      await fsp.rename(extractedDir, finalDir);
+    } catch (error) {
+      // Another process may have installed this exact version while we downloaded.
+      const winner = await existingBundle(finalDir);
+      if (winner) return winner;
+      if (error.code === 'EEXIST' || error.code === 'ENOTEMPTY') {
+        throw new Error(`The scrcpy cache at ${finalDir} is incomplete. Remove that directory and retry.`);
+      }
+      throw error;
+    }
+    return { scrcpyPath: path.join(finalDir, 'scrcpy'), adbPath: path.join(finalDir, 'adb') };
+  } finally {
+    if (isContainedChild(root, stage)) {
+      await fsp.rm(stage, { recursive: true, force: true });
+    }
+  }
+}
+
+module.exports = { ensureMacScrcpy };

package/lib/mac-viewer.js

@@ -0,0 +1,284 @@
+'use strict';
+
+const fs = require('node:fs');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+
+const serial = '127.0.0.1:15555';
+const supportedDevices = new Set(['pixel8', 'pixel_8', 'pixel-8', serial]);
+const supportedActions = new Set(['control', 'wake', 'lock', 'restart', 'status']);
+const defaults = Object.freeze({ sshPort: 22, adbForwardPort: 5038, videoPort: 27183, timeLimitSeconds: 0 });
+
+function integerOption(value, name, minimum, maximum) {
+  if (!/^[0-9]+$/.test(value || '')) throw new Error(`${name} must be a number from ${minimum} to ${maximum}.`);
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < minimum || number > maximum) {
+    throw new Error(`${name} must be a number from ${minimum} to ${maximum}.`);
+  }
+  return number;
+}
+
+function parseMacOptions(args) {
+  const result = { ...defaults };
+  const names = new Map([
+    ['-centralhost', 'host'], ['-centraluser', 'user'], ['-sshport', 'sshPort'],
+    ['-adbforwardport', 'adbForwardPort'], ['-videoport', 'videoPort'],
+    ['-timelimitseconds', 'timeLimitSeconds'], ['-scrcpypath', 'scrcpyPath'], ['-adbpath', 'adbPath'],
+  ]);
+  const seen = new Set();
+  for (let index = 0; index < args.length; index += 2) {
+    const name = args[index];
+    const key = typeof name === 'string' ? names.get(name.toLowerCase()) : null;
+    const value = args[index + 1];
+    if (!key || !value) {
+      throw new Error(`Unknown or incomplete option '${name || ''}'. Run pixelremotecontrol --help.`);
+    }
+    if (seen.has(key)) throw new Error(`Specify ${name} only once.`);
+    seen.add(key);
+    result[key] = value;
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9.:-]*$/.test(result.host || '')) {
+    throw new Error('Invalid relay host. Run pixelremotecontrol setup --host RELAY_HOST --user SSH_USER.');
+  }
+  if (!/^[A-Za-z0-9_][A-Za-z0-9._-]*$/.test(result.user || '')) {
+    throw new Error('Invalid relay SSH username. Run pixelremotecontrol setup --host RELAY_HOST --user SSH_USER.');
+  }
+  result.sshPort = integerOption(result.sshPort.toString(), '-SshPort', 1, 65535);
+  result.adbForwardPort = integerOption(result.adbForwardPort.toString(), '-AdbForwardPort', 1024, 65535);
+  result.videoPort = integerOption(result.videoPort.toString(), '-VideoPort', 1024, 65535);
+  result.timeLimitSeconds = integerOption(result.timeLimitSeconds.toString(), '-TimeLimitSeconds', 0, 86400);
+  if (result.adbForwardPort === result.videoPort) {
+    throw new Error('-AdbForwardPort and -VideoPort must differ.');
+  }
+  return result;
+}
+
+function buildSshArgs(action, options) {
+  const destination = `${options.user}@${options.host}`;
+  if (action !== 'control') {
+    return ['-T', '-p', String(options.sshPort), destination, `pixelctl.cmd ${action}`];
+  }
+  return [
+    '-T', '-o', 'ExitOnForwardFailure=yes', '-o', 'ServerAliveInterval=15',
+    '-o', 'ServerAliveCountMax=3', '-p', String(options.sshPort),
+    '-L', `127.0.0.1:${options.adbForwardPort}:127.0.0.1:5039`,
+    '-L', `127.0.0.1:${options.videoPort}:127.0.0.1:${options.videoPort}`,
+    destination, 'pixelctl.cmd serve',
+  ];
+}
+
+function buildScrcpyArgs(options) {
+  const args = ['--force-adb-forward', `--port=${options.videoPort}`, '--serial', serial];
+  if (options.timeLimitSeconds > 0) args.push(`--time-limit=${options.timeLimitSeconds}`);
+  return args;
+}
+
+function pause(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function testPortOpen(port) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let done = false;
+    const finish = (open) => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      resolve(open);
+    };
+    socket.setTimeout(250);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+    socket.connect(port, '127.0.0.1');
+  });
+}
+
+function assertPortFree(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once('error', () => reject(new Error(
+      `Local port ${port} is already in use. Close the other viewer or choose another forward port.`
+    )));
+    server.listen(port, '127.0.0.1', () => server.close(resolve));
+  });
+}
+
+function stopChild(child) {
+  if (!child || !child.pid || child.killed || child.exitCode !== null || child.signalCode !== null) return;
+  child.kill('SIGTERM');
+  const force = setTimeout(() => {
+    if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
+  }, 3000);
+  force.unref();
+  child.once('close', () => clearTimeout(force));
+}
+
+function runChild(program, args, { env = process.env, stdio = 'inherit', timeoutMs = 0, tracked } = {}) {
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(program, args, { env, stdio });
+    } catch (error) {
+      reject(new Error(`Cannot launch ${program}: ${error.message}`));
+      return;
+    }
+    if (tracked) tracked.add(child);
+    let output = '';
+    let timer;
+    if (stdio !== 'inherit') {
+      for (const stream of [child.stdout, child.stderr]) {
+        stream.on('data', (chunk) => { output = (output + chunk.toString()).slice(-16384); });
+      }
+    }
+    if (timeoutMs) {
+      timer = setTimeout(() => stopChild(child), timeoutMs);
+      timer.unref();
+    }
+    child.once('error', (error) => reject(new Error(`Cannot launch ${program}: ${error.message}`)));
+    child.once('close', (code, signal) => {
+      if (timer) clearTimeout(timer);
+      if (tracked) tracked.delete(child);
+      resolve({ code: code === null ? 1 : code, signal, output });
+    });
+  });
+}
+
+function checkSession(session) {
+  if (session.interrupted) throw new Error('Interrupted.');
+  if (session.sshError) throw new Error(`Could not open SSH: ${session.sshError.message}`);
+  if (session.sshClosed) {
+    throw new Error(`SSH ended with code ${session.sshCode === null ? 'unknown' : session.sshCode}. Check the relay login and Pixel service.`);
+  }
+}
+
+async function waitForForward(session, port) {
+  const deadline = Date.now() + 120000;
+  while (Date.now() < deadline) {
+    checkSession(session);
+    if (await testPortOpen(port)) return;
+    await pause(200);
+  }
+  throw new Error('SSH forwarding did not open within two minutes. Check the relay login and password prompt.');
+}
+
+async function deviceReady(adbPath, env, tracked) {
+  const connect = await runChild(adbPath, ['connect', serial], { env, stdio: 'pipe', timeoutMs: 10000, tracked });
+  if (connect.code !== 0) return { ready: false, message: connect.output.trim() };
+  const devices = await runChild(adbPath, ['devices', '-l'], { env, stdio: 'pipe', timeoutMs: 10000, tracked });
+  return {
+    ready: devices.code === 0 && new RegExp(`^${serial.replaceAll('.', '\\.')}\\s+device\\b`, 'm').test(devices.output),
+    message: devices.output.trim() || connect.output.trim(),
+  };
+}
+
+async function waitForDevice(session, adbPath, env, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastMessage = '';
+  let announced = false;
+  while (Date.now() < deadline) {
+    checkSession(session);
+    const result = await deviceReady(adbPath, env, session.tracked);
+    if (result.ready) return;
+    lastMessage = result.message;
+    if (!announced) {
+      process.stdout.write('Waiting for the Pixel through the relay...\n');
+      announced = true;
+    }
+    await pause(1000);
+  }
+  const approval = /unauthorized/i.test(lastMessage)
+    ? ' Approve the Android debugging prompt on the Pixel.' : '';
+  throw new Error(`The Pixel did not become available through the relay. Ask the holder to run ` +
+    `'pixelremotecontrol startservice pixel8 asml' in Termux.${approval}` +
+    (lastMessage ? ` Last ADB response: ${lastMessage}` : ''));
+}
+
+async function runMacControl(options) {
+  const { ensureMacScrcpy } = require('./mac-dependencies.js');
+  const installed = options.scrcpyPath && options.adbPath ? null : await ensureMacScrcpy();
+  const scrcpyPath = options.scrcpyPath || installed.scrcpyPath;
+  const adbPath = options.adbPath || installed.adbPath;
+  for (const [name, program] of [['scrcpy', scrcpyPath], ['adb', adbPath]]) {
+    if (!fs.existsSync(program)) throw new Error(`${name} was not found at '${program}'.`);
+  }
+  await assertPortFree(options.adbForwardPort);
+  await assertPortFree(options.videoPort);
+
+  const session = { interrupted: false, sshClosed: false, sshCode: null, sshError: null, tracked: new Set() };
+  let interruptCode = 130;
+  const interrupt = (code) => {
+    interruptCode = code;
+    session.interrupted = true;
+    for (const child of session.tracked) stopChild(child);
+  };
+  const onSigint = () => interrupt(130);
+  const onSigterm = () => interrupt(143);
+  process.once('SIGINT', onSigint);
+  process.once('SIGTERM', onSigterm);
+  try {
+    const destination = `${options.user}@${options.host}`;
+    process.stdout.write(`Opening SSH to ${destination}. Complete any login prompt in this terminal.\n`);
+    const ssh = spawn('ssh', buildSshArgs('control', options), { stdio: 'inherit' });
+    session.tracked.add(ssh);
+    ssh.once('error', (error) => { session.sshError = error; });
+    ssh.once('close', (code) => {
+      session.sshClosed = true;
+      session.sshCode = code;
+      session.tracked.delete(ssh);
+    });
+
+    await waitForForward(session, options.adbForwardPort);
+    const env = {
+      ...process.env,
+      ADB_SERVER_SOCKET: `tcp:127.0.0.1:${options.adbForwardPort}`,
+      ADB: adbPath,
+    };
+    await waitForDevice(session, adbPath, env, 60000);
+    process.stdout.write('Pixel connected. Close the scrcpy window to end this session.\n');
+    for (let attempt = 0; attempt < 3; attempt++) {
+      checkSession(session);
+      const result = await runChild(scrcpyPath, buildScrcpyArgs(options), { env, tracked: session.tracked });
+      if (session.interrupted) return interruptCode;
+      if (result.code === 0) return 0;
+      checkSession(session);
+      if (attempt === 2) break;
+      const current = await deviceReady(adbPath, env, session.tracked);
+      // A transient scrcpy failure can leave ADB reporting the device as ready.
+      // Retry that case once; a persistent local error should fail promptly.
+      if (current.ready && attempt > 0) break;
+      process.stdout.write(`Screen connection dropped. Reconnecting (${attempt + 1}/2)...\n`);
+      if (current.ready) await pause(1500);
+      else await waitForDevice(session, adbPath, env, 30000);
+    }
+    throw new Error('scrcpy exited unexpectedly. Check the Pixel service and retry control local pixel8.');
+  } catch (error) {
+    if (session.interrupted) return interruptCode;
+    throw error;
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+    process.removeListener('SIGTERM', onSigterm);
+    for (const child of session.tracked) stopChild(child);
+  }
+}
+
+async function runMacAction(action, display, deviceId, args) {
+  if (!supportedActions.has(action)) throw new Error(`Unknown action '${action}'. Run pixelremotecontrol --help.`);
+  const target = (display || 'local').toLowerCase();
+  if (!['local', 'thismachine', 'asml'].includes(target)) {
+    throw new Error(`Unknown display '${display}'. Use local or asml.`);
+  }
+  if (!supportedDevices.has((deviceId || 'pixel8').toLowerCase())) {
+    throw new Error(`Unknown device '${deviceId}'. This relay currently has one registered device: pixel8 (Pixel_8).`);
+  }
+  if (action === 'control' && target === 'asml') {
+    throw new Error('ASML screen mode needs an interactive Windows desktop session on ASML. Use "control local pixel8" on this Mac, or open an ASML desktop through Remote Desktop.');
+  }
+  const options = parseMacOptions(args);
+  if (action === 'control') return runMacControl(options);
+  const result = await runChild('ssh', buildSshArgs(action, options));
+  return result.code;
+}
+
+module.exports = { runMacAction, parseMacOptions, buildSshArgs, buildScrcpyArgs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixelremotecontrol",
-  "version": "0.1.0",
-  "description": "Control a paired Pixel through a private ASML SSH relay",
+  "version": "0.2.0",
+  "description": "Control a paired Pixel through a private SSH relay from Windows or macOS",
   "license": "UNLICENSED",
   "private": false,
   "contentPolicy": {