@jian-ai/remote-control 0.7.2 → 0.8.0

package/bin/computer-macos.mjs

@@ -0,0 +1,479 @@
+/**
+ * macOS computer-use: primary-display screenshots, coord mapping, Jian overlay helper.
+ * English-only messages. Imported by jian-remote.mjs on darwin.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const COMPUTER_CAPABILITY = 'computer-macos-v1';
+const IDLE_MS = 30_000;
+const HELPER_NAME = 'computer-helper';
+
+/** Map screenshot image pixels → display points (primary). Half-pixel centers the click. */
+export function imagePixelToPoint(x, y, geometry) {
+  const { originX, originY, pointWidth, pointHeight, widthPx, heightPx } = geometry;
+  if (!(widthPx > 0 && heightPx > 0 && pointWidth > 0 && pointHeight > 0)) {
+    throw new Error('Invalid screenshot geometry for coordinate mapping');
+  }
+  return {
+    pointX: originX + (x + 0.5) * (pointWidth / widthPx),
+    pointY: originY + (y + 0.5) * (pointHeight / heightPx),
+  };
+}
+
+export function scaleFromGeometry(geometry) {
+  return {
+    imageToPointX: geometry.pointWidth / geometry.widthPx,
+    imageToPointY: geometry.pointHeight / geometry.heightPx,
+  };
+}
+
+/** Capture primary display and compress like the gateway’s former screenshotCommand. */
+export function capturePrimaryScreenshotBase64() {
+  const script = [
+    'tmp=$(mktemp /tmp/jian-shot.XXXXXX.jpg);',
+    'screencapture -x -t jpg -D 1 "$tmp" || { rm -f "$tmp"; exit 1; };',
+    'sips -Z 1920 -s format jpeg -s formatOptions 50 "$tmp" >/dev/null 2>&1 || true;',
+    'size=$(wc -c < "$tmp" | tr -d " ");',
+    'if [ "$size" -gt 280000 ]; then sips -Z 1440 -s format jpeg -s formatOptions 40 "$tmp" >/dev/null 2>&1 || true; fi;',
+    'size=$(wc -c < "$tmp" | tr -d " ");',
+    'if [ "$size" -gt 280000 ]; then sips -Z 1280 -s format jpeg -s formatOptions 35 "$tmp" >/dev/null 2>&1 || true; fi;',
+    'w=$(sips -g pixelWidth "$tmp" 2>/dev/null | awk "/pixelWidth/{print \\$2}");',
+    'h=$(sips -g pixelHeight "$tmp" 2>/dev/null | awk "/pixelHeight/{print \\$2}");',
+    'echo "$w $h";',
+    'base64 < "$tmp";',
+    'rm -f "$tmp"',
+  ].join(' ');
+  const result = spawnSync('/bin/sh', ['-lc', script], {
+    encoding: 'utf8',
+    maxBuffer: 600_000,
+  });
+  if (result.status !== 0) {
+    const err = (result.stderr || result.stdout || 'Screenshot failed').trim();
+    throw new Error(
+      /not authorized|capture/i.test(err)
+        ? 'Jian Remote needs Screen Recording permission in System Settings.'
+        : err || 'Screenshot failed',
+    );
+  }
+  const out = result.stdout || '';
+  const nl = out.indexOf('\n');
+  if (nl < 0) throw new Error('Screenshot produced no image data.');
+  const [wRaw, hRaw] = out.slice(0, nl).trim().split(/\s+/);
+  const widthPx = Number(wRaw);
+  const heightPx = Number(hRaw);
+  const base64 = out.slice(nl + 1).replace(/\s+/g, '');
+  if (!Number.isFinite(widthPx) || !Number.isFinite(heightPx) || widthPx < 1 || heightPx < 1) {
+    throw new Error('Could not read screenshot dimensions.');
+  }
+  if (!base64) throw new Error('Screenshot produced no image data.');
+  return { base64, widthPx, heightPx };
+}
+
+function helperPaths() {
+  const support = join(homedir(), 'Library', 'Application Support', 'Jian Remote');
+  return {
+    support,
+    source: join(support, `${HELPER_NAME}.swift`),
+    binary: join(support, HELPER_NAME),
+  };
+}
+
+function packageSwiftPath() {
+  return join(dirname(fileURLToPath(import.meta.url)), '..', 'macos', `${HELPER_NAME}.swift`);
+}
+
+async function ensureHelperBinary() {
+  const paths = helperPaths();
+  await mkdir(paths.support, { recursive: true, mode: 0o755 });
+  let sourceText;
+  try {
+    sourceText = await readFile(packageSwiftPath(), 'utf8');
+  } catch {
+    try {
+      sourceText = await readFile(paths.source, 'utf8');
+    } catch {
+      throw new Error(
+        'Computer-use helper source is missing. Reinstall or update @jian-ai/remote-control.',
+      );
+    }
+  }
+  const hash = createHash('sha256').update(sourceText).digest('hex').slice(0, 16);
+  const stamp = join(paths.support, `${HELPER_NAME}.sha256`);
+  let previous = '';
+  try {
+    previous = (await readFile(stamp, 'utf8')).trim();
+  } catch {
+    previous = '';
+  }
+  const needsBuild = previous !== hash || !existsSync(paths.binary);
+  await writeFile(paths.source, sourceText, { mode: 0o644 });
+  if (needsBuild) {
+    const compiled = spawnSync(
+      'swiftc',
+      ['-O', '-framework', 'AppKit', '-framework', 'Carbon', '-o', paths.binary, paths.source],
+      { encoding: 'utf8' },
+    );
+    if (compiled.status !== 0) {
+      throw new Error(
+        (compiled.stderr || compiled.stdout || 'swiftc failed').trim() ||
+          'Could not build the Jian computer-use helper. Install Xcode Command Line Tools.',
+      );
+    }
+    await chmod(paths.binary, 0o755);
+    await writeFile(stamp, `${hash}\n`, { mode: 0o644 });
+  }
+  return paths.binary;
+}
+
+/** Copy Swift sources next to the installed worker when present in the npm package. */
+export async function materializeComputerHelperSources(configDir) {
+  if (process.platform !== 'darwin') return;
+  try {
+    const from = packageSwiftPath();
+    if (!existsSync(from)) return;
+    const support = join(homedir(), 'Library', 'Application Support', 'Jian Remote');
+    await mkdir(support, { recursive: true, mode: 0o755 });
+    await copyFile(from, join(support, `${HELPER_NAME}.swift`));
+    const localMacos = join(configDir, 'macos');
+    await mkdir(localMacos, { recursive: true, mode: 0o755 });
+    await copyFile(from, join(localMacos, `${HELPER_NAME}.swift`));
+  } catch {
+    // Best-effort on install; computer session will surface a clear error.
+  }
+}
+
+export class MacComputerSession {
+  constructor() {
+    this.child = null;
+    this.buffer = '';
+    this.pending = [];
+    this.geometry = null;
+    this.shotGeometry = null;
+    this.idleTimer = null;
+    this.active = false;
+  }
+
+  async ensure() {
+    if (this.child && !this.child.killed) {
+      await this.send({ cmd: 'ensureSession' });
+      this.active = true;
+      this.bumpIdle();
+      return;
+    }
+    const binary = await ensureHelperBinary();
+    this.child = spawn(binary, [], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    this.buffer = '';
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk) => this.onData(chunk));
+    this.child.stderr.on('data', (chunk) => {
+      const text = chunk.toString('utf8').trim();
+      if (text) console.error(text);
+    });
+    this.child.on('exit', () => {
+      this.failAll('Computer-use helper exited unexpectedly.');
+      this.child = null;
+      this.active = false;
+    });
+    const ping = await this.send({ cmd: 'ping' });
+    if (!ping.ok) throw new Error(ping.error || 'Computer-use helper did not respond.');
+    const geo = await this.send({ cmd: 'geometry' });
+    if (!geo.ok) throw new Error(geo.error || 'Could not read display geometry.');
+    this.geometry = {
+      originX: Number(geo.originX) || 0,
+      originY: Number(geo.originY) || 0,
+      pointWidth: Number(geo.pointWidth),
+      pointHeight: Number(geo.pointHeight),
+      pixelWidth: Number(geo.pixelWidth),
+      pixelHeight: Number(geo.pixelHeight),
+      scaleFactor: Number(geo.scaleFactor) || 1,
+    };
+    await this.send({ cmd: 'ensureSession' });
+    this.active = true;
+    this.bumpIdle();
+  }
+
+  bumpIdle() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      if (!this.active || !this.child) return;
+      void this.send({ cmd: 'setIdle' }).catch(() => {});
+    }, IDLE_MS);
+    this.idleTimer.unref?.();
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    for (;;) {
+      const idx = this.buffer.indexOf('\n');
+      if (idx < 0) break;
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        this.failNext('Computer-use helper returned invalid JSON.');
+        continue;
+      }
+      const next = this.pending.shift();
+      if (next) next.resolve(parsed);
+    }
+  }
+
+  failNext(message) {
+    const next = this.pending.shift();
+    if (next) next.reject(new Error(message));
+  }
+
+  failAll(message) {
+    while (this.pending.length) {
+      this.pending.shift().reject(new Error(message));
+    }
+  }
+
+  send(payload) {
+    return new Promise((resolve, reject) => {
+      if (!this.child?.stdin) {
+        reject(new Error('Computer-use helper is not running.'));
+        return;
+      }
+      this.pending.push({ resolve, reject });
+      this.child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+        if (error) {
+          this.pending.pop();
+          reject(error);
+        }
+      });
+    });
+  }
+
+  requireShotGeometry() {
+    if (!this.shotGeometry) {
+      throw new Error('Take a screenshot before using screen coordinates.');
+    }
+    return this.shotGeometry;
+  }
+
+  mapCoordinate(coordinate) {
+    const [x, y] = coordinate;
+    const shot = this.requireShotGeometry();
+    if (x < 0 || y < 0 || x >= shot.widthPx || y >= shot.heightPx) {
+      throw new Error(
+        `Coordinate (${x}, ${y}) is outside the last screenshot (${shot.widthPx}×${shot.heightPx}).`,
+      );
+    }
+    return imagePixelToPoint(x, y, shot);
+  }
+
+  async end() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+    if (this.child) {
+      try {
+        await this.send({ cmd: 'endSession' });
+      } catch {
+        // ignore
+      }
+      this.child.kill('SIGTERM');
+      this.child = null;
+    }
+    this.active = false;
+    this.shotGeometry = null;
+    this.geometry = null;
+  }
+
+  async runAction(computer) {
+    const { action } = computer;
+    if (action === 'end_session') {
+      await this.end();
+      return {
+        exitCode: 0,
+        stdout: '',
+        stderr: '',
+        timedOut: false,
+        computer: { ok: true },
+      };
+    }
+
+    if (action === 'wait') {
+      const ms = Math.round((computer.duration ?? 0.5) * 1000);
+      await new Promise((r) => setTimeout(r, ms));
+      if (this.active) this.bumpIdle();
+      return {
+        exitCode: 0,
+        stdout: '',
+        stderr: '',
+        timedOut: false,
+        computer: { ok: true },
+      };
+    }
+
+    if (action === 'screenshot') {
+      await this.ensure();
+      const shot = capturePrimaryScreenshotBase64();
+      if (!this.geometry) throw new Error('Display geometry unavailable.');
+      this.shotGeometry = {
+        ...this.geometry,
+        widthPx: shot.widthPx,
+        heightPx: shot.heightPx,
+      };
+      this.bumpIdle();
+      return {
+        exitCode: 0,
+        stdout: shot.base64,
+        stderr: '',
+        timedOut: false,
+        computer: {
+          ok: true,
+          widthPx: shot.widthPx,
+          heightPx: shot.heightPx,
+          scale: scaleFromGeometry(this.shotGeometry),
+        },
+      };
+    }
+
+    await this.ensure();
+
+    try {
+      if (
+        action === 'mouse_move' ||
+        action === 'left_click' ||
+        action === 'right_click' ||
+        action === 'double_click'
+      ) {
+        if (!computer.coordinate) throw new Error('coordinate is required for this action.');
+        const { pointX, pointY } = this.mapCoordinate(computer.coordinate);
+        const moved = await this.send({ cmd: 'move', pointX, pointY });
+        if (!moved.ok) throw new Error(moved.error || 'Move failed.');
+        if (action !== 'mouse_move') {
+          const button = action === 'right_click' ? 'right' : 'left';
+          const count = action === 'double_click' ? 2 : 1;
+          const clicked = await this.send({ cmd: 'click', button, count });
+          if (!clicked.ok) throw new Error(clicked.error || 'Click failed.');
+        }
+      } else if (action === 'left_click_drag') {
+        if (!computer.startCoordinate || !computer.coordinate) {
+          throw new Error('startCoordinate and coordinate are required for drag.');
+        }
+        const from = this.mapCoordinate(computer.startCoordinate);
+        const to = this.mapCoordinate(computer.coordinate);
+        const dragged = await this.send({
+          cmd: 'drag',
+          fromX: from.pointX,
+          fromY: from.pointY,
+          toX: to.pointX,
+          toY: to.pointY,
+        });
+        if (!dragged.ok) throw new Error(dragged.error || 'Drag failed.');
+      } else if (action === 'type') {
+        if (!computer.text) throw new Error('text is required for type.');
+        const typed = await this.send({ cmd: 'type', text: computer.text });
+        if (!typed.ok) throw new Error(typed.error || 'Type failed.');
+      } else if (action === 'key') {
+        if (!computer.key) throw new Error('key is required for key.');
+        const keyed = await this.send({ cmd: 'key', key: computer.key });
+        if (!keyed.ok) throw new Error(keyed.error || 'Key failed.');
+      } else if (action === 'scroll') {
+        if (!computer.coordinate) throw new Error('coordinate is required for scroll.');
+        if (!computer.scrollDirection) throw new Error('scrollDirection is required for scroll.');
+        const { pointX, pointY } = this.mapCoordinate(computer.coordinate);
+        const scrolled = await this.send({
+          cmd: 'scroll',
+          pointX,
+          pointY,
+          direction: computer.scrollDirection,
+          amount: computer.scrollAmount ?? 3,
+        });
+        if (!scrolled.ok) throw new Error(scrolled.error || 'Scroll failed.');
+      } else {
+        throw new Error(`Unsupported computer action: ${action}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const tcc = /accessib|not permitted|not authorized/i.test(message)
+        ? ' Jian Remote needs Accessibility (and Screen Recording for screenshots) in System Settings.'
+        : '';
+      return {
+        exitCode: 1,
+        stdout: '',
+        stderr: `${message}${tcc}`,
+        timedOut: false,
+        computer: { ok: false, error: `${message}${tcc}`.trim() },
+      };
+    }
+
+    this.bumpIdle();
+    return {
+      exitCode: 0,
+      stdout: '',
+      stderr: '',
+      timedOut: false,
+      computer: { ok: true },
+    };
+  }
+}
+
+let sharedSession = null;
+
+export function computerSession() {
+  if (!sharedSession) sharedSession = new MacComputerSession();
+  return sharedSession;
+}
+
+export async function executeComputerTask(task) {
+  const session = computerSession();
+  const computer = task.computer;
+  if (!computer?.action) {
+    return {
+      taskId: task.id,
+      exitCode: 1,
+      stdout: '',
+      stderr: 'Computer task missing action.',
+      timedOut: false,
+      computer: { ok: false, error: 'Computer task missing action.' },
+    };
+  }
+  const timeoutMs = task.timeoutMs || 30_000;
+  let timedOut = false;
+  const result = await Promise.race([
+    session.runAction(computer),
+    new Promise((resolve) => {
+      setTimeout(() => {
+        timedOut = true;
+        resolve({
+          exitCode: null,
+          stdout: '',
+          stderr: 'Computer action timed out',
+          timedOut: true,
+          computer: { ok: false, error: 'Computer action timed out' },
+        });
+      }, timeoutMs);
+    }),
+  ]);
+  return { taskId: task.id, ...result, timedOut: timedOut || Boolean(result.timedOut) };
+}
+
+/** Probe whether this Mac can advertise computer-use (helper builds). */
+export async function probeComputerCapability() {
+  if (process.platform !== 'darwin') return false;
+  try {
+    await ensureHelperBinary();
+    return true;
+  } catch {
+    // Still advertise: screenshot-only path can work; input fails with TCC guidance.
+    // Prefer advertising when swiftc exists so gateway can send jobs after first grant.
+    return (
+      Boolean(spawnSync('which', ['swiftc'], { encoding: 'utf8' }).stdout?.trim()) ||
+      existsSync(helperPaths().binary)
+    );
+  }
+}

package/bin/jian-remote.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { chmod, copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const configDir = join(homedir(), '.config', 'jian-remote');
@@ -21,7 +21,7 @@ const option = (name) => {
  * Stamped to the release tag on npm publish and when the gateway serves this script.
  * Compatibility with the gateway requires the same major.minor (see versionsCompatible).
  */
-export const PACKAGE_VERSION = '0.7.2';
+export const PACKAGE_VERSION = '0.8.0';
 
 /** Soft stdout/stderr caps while capturing a command (chars). Gateway schema matches these. */
 const STDOUT_CAP = 400_000;
@@ -256,6 +256,7 @@ export function cappedAppend(current, chunk, cap = STDOUT_CAP) {
 export function fitResult(result, budget = RESULT_BODY_BUDGET) {
   let stdout = result.stdout ?? '';
   let stderr = result.stderr ?? '';
+  const computer = result.computer;
   const pack = () =>
     JSON.stringify({
       taskId: result.taskId,
@@ -263,10 +264,14 @@ export function fitResult(result, budget = RESULT_BODY_BUDGET) {
       stdout,
       stderr,
       timedOut: Boolean(result.timedOut),
+      ...(computer ? { computer } : {}),
     });
   let body = pack();
   if (Buffer.byteLength(body) <= budget) {
-    return { result: { ...result, stdout, stderr, timedOut: Boolean(result.timedOut) }, body };
+    return {
+      result: { ...result, stdout, stderr, timedOut: Boolean(result.timedOut), computer },
+      body,
+    };
   }
 
   const note = '\n… truncated to fit the gateway size limit';
@@ -481,6 +486,22 @@ async function materializeWorkerScript(sourceBytes) {
     if (source !== installedScript) await copyFile(source, installedScript);
   }
   if (process.platform !== 'win32') await chmod(installedScript, 0o700);
+  // Companion modules + macOS helper source (computer use). Best-effort beside the worker.
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const computerSrc = join(here, 'computer-macos.mjs');
+    const computerDest = join(configDir, 'computer-macos.mjs');
+    if (existsSync(computerSrc) && computerSrc !== computerDest) {
+      await copyFile(computerSrc, computerDest);
+      if (process.platform !== 'win32') await chmod(computerDest, 0o700);
+    }
+    if (process.platform === 'darwin') {
+      const { materializeComputerHelperSources } = await import('./computer-macos.mjs');
+      await materializeComputerHelperSources(configDir);
+    }
+  } catch {
+    // Install still succeeds; computer-use probe will explain if the helper is missing.
+  }
   return installedScript;
 }
 
@@ -731,7 +752,7 @@ async function update() {
   printSuccess('Updated Jian Remote', facts);
 }
 
-async function execute(task) {
+async function executeShell(task) {
   return await new Promise((resolveResult) => {
     const command = process.platform === 'win32' ? 'powershell.exe' : '/bin/sh';
     const commandArgs =
@@ -793,6 +814,24 @@ async function execute(task) {
   });
 }
 
+async function execute(task) {
+  if (task.kind === 'computer') {
+    if (process.platform !== 'darwin') {
+      return {
+        taskId: task.id,
+        exitCode: 1,
+        stdout: '',
+        stderr: 'Computer use is supported on macOS Jian Remote only.',
+        timedOut: false,
+        computer: { ok: false, error: 'Computer use is supported on macOS Jian Remote only.' },
+      };
+    }
+    const { executeComputerTask } = await import('./computer-macos.mjs');
+    return executeComputerTask(task);
+  }
+  return executeShell(task);
+}
+
 async function updateIfNeeded(base, headers) {
   // Prefer the installed copy under ~/.config so updates land where the service points.
   const script = installedScript;
@@ -900,16 +939,26 @@ async function postResult(base, headers, result) {
 
 async function run() {
   const config = await loadConfig();
+  const capabilities = [];
+  if (process.platform === 'darwin') {
+    try {
+      const { probeComputerCapability, COMPUTER_CAPABILITY } = await import('./computer-macos.mjs');
+      if (await probeComputerCapability()) capabilities.push(COMPUTER_CAPABILITY);
+    } catch {
+      // Computer use unavailable until helper builds; shell tasks still work.
+    }
+  }
   const headers = {
     authorization: `Bearer ${config.token}`,
     'x-jian-platform': `${process.platform}-${process.arch}`,
     'x-jian-remote-version': PACKAGE_VERSION,
+    ...(capabilities.length ? { 'x-jian-remote-capabilities': capabilities.join(',') } : {}),
   };
   const base = `${config.gateway}/v1/remote/worker/${config.machineId}`;
   // Fail fast before the poll loop so an incompatible build does not look "online then stuck".
   const gatewayVersion = await assertCompatibleWithGateway(config.gateway);
   console.log(
-    `Connected to Jian Remote at ${config.gateway} (worker ${PACKAGE_VERSION}${gatewayVersion ? `, gateway ${gatewayVersion}` : ''})`,
+    `Connected to Jian Remote at ${config.gateway} (worker ${PACKAGE_VERSION}${gatewayVersion ? `, gateway ${gatewayVersion}` : ''}${capabilities.length ? `, capabilities ${capabilities.join(',')}` : ''})`,
   );
   let failures = 0;
   let nextUpdateCheck = 0;

package/macos/computer-helper.swift

@@ -0,0 +1,735 @@
+/*
+  Jian Remote Control — macOS computer-use helper
+
+  Long-lived AppKit process: overlay pointer + synthetic mouse/keyboard via CoreGraphics.
+  Protocol: newline-delimited JSON on stdin → newline-delimited JSON on stdout (flush each).
+  Errors go to stderr in English only.
+
+  Build (on a Mac with Xcode CLT):
+    swiftc -O -framework AppKit -framework Carbon -o computer-helper computer-helper.swift
+
+  Run as a child of the Node worker; keep stdin/stdout pipes open for the session.
+*/
+
+import AppKit
+import Carbon.HIToolbox
+import CoreGraphics
+import Foundation
+
+// MARK: - JSON I/O
+
+private func writeResponse(_ object: [String: Any]) {
+  guard JSONSerialization.isValidJSONObject(object),
+    let data = try? JSONSerialization.data(withJSONObject: object, options: []),
+    var line = String(data: data, encoding: .utf8)
+  else {
+    fputs("computer-helper: failed to encode response JSON\n", stderr)
+    fflush(stderr)
+    return
+  }
+  line.append("\n")
+  FileHandle.standardOutput.write(Data(line.utf8))
+  fflush(stdout)
+}
+
+private func writeOk(_ extra: [String: Any] = [:]) {
+  var body: [String: Any] = ["ok": true]
+  for (key, value) in extra {
+    body[key] = value
+  }
+  writeResponse(body)
+}
+
+private func writeError(_ message: String) {
+  writeResponse(["ok": false, "error": message])
+}
+
+private func logError(_ message: String) {
+  fputs("computer-helper: \(message)\n", stderr)
+  fflush(stderr)
+}
+
+private func parseJSONLine(_ line: String) -> [String: Any]? {
+  let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
+  guard !trimmed.isEmpty, let data = trimmed.data(using: .utf8) else { return nil }
+  guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+    return nil
+  }
+  return object
+}
+
+private func doubleValue(_ object: [String: Any], _ key: String) -> Double? {
+  if let n = object[key] as? Double { return n }
+  if let n = object[key] as? Int { return Double(n) }
+  if let n = object[key] as? NSNumber { return n.doubleValue }
+  return nil
+}
+
+private func intValue(_ object: [String: Any], _ key: String) -> Int? {
+  if let n = object[key] as? Int { return n }
+  if let n = object[key] as? Double { return Int(n) }
+  if let n = object[key] as? NSNumber { return n.intValue }
+  return nil
+}
+
+// MARK: - Colors (Jian UI)
+
+private let jianCream = NSColor(srgbRed: 0xF5 / 255, green: 0xF5 / 255, blue: 0xF3 / 255, alpha: 1)
+private let jianInk = NSColor(srgbRed: 0x17 / 255, green: 0x17 / 255, blue: 0x16 / 255, alpha: 1)
+
+private let sessionAlpha: CGFloat = 0.92
+private let idleAlpha: CGFloat = 0.18
+private let pointerSize: CGFloat = 32
+/// Tip of the wing relative to the view's top-left (hotspot for cursor placement).
+private let hotspot = CGPoint(x: 4, y: 4)
+
+// MARK: - Overlay view
+
+private final class JianPointerView: NSView {
+  private var rippleProgress: CGFloat = 0
+  private var rippleVisible = false
+  private var fillPulse: CGFloat = 0
+  private var rippleTimer: Timer?
+
+  override var isFlipped: Bool { true }
+
+  override func draw(_ dirtyRect: NSRect) {
+    guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+
+    if rippleVisible {
+      let maxRadius = pointerSize * 0.95
+      let radius = 4 + maxRadius * rippleProgress
+      let alpha = max(0, 1 - rippleProgress)
+      ctx.saveGState()
+      ctx.setStrokeColor(jianInk.withAlphaComponent(0.55 * alpha).cgColor)
+      ctx.setLineWidth(1.5)
+      ctx.strokeEllipse(in: CGRect(
+        x: hotspot.x - radius,
+        y: hotspot.y - radius,
+        width: radius * 2,
+        height: radius * 2
+      ))
+      ctx.restoreGState()
+    }
+
+    let path = Self.wingPath(in: bounds)
+    ctx.saveGState()
+    ctx.setShadow(offset: CGSize(width: 0, height: 1.5), blur: 4, color: NSColor.black.withAlphaComponent(0.28).cgColor)
+    let fillAlpha = 1 - fillPulse * 0.35
+    jianCream.withAlphaComponent(fillAlpha).setFill()
+    path.fill()
+    ctx.restoreGState()
+
+    jianInk.setStroke()
+    path.lineWidth = 2
+    path.lineJoinStyle = .round
+    path.lineCapStyle = .round
+    path.stroke()
+  }
+
+  /// Ascending wing mark inspired by the Jian brand path (favicon / mark.tsx).
+  private static func wingPath(in bounds: NSRect) -> NSBezierPath {
+    let s = min(bounds.width, bounds.height)
+    let path = NSBezierPath()
+    // Tip near top-left (hotspot), body sweeping down-right then curling back — one ascending wing.
+    path.move(to: CGPoint(x: s * 0.12, y: s * 0.10))
+    path.curve(
+      to: CGPoint(x: s * 0.72, y: s * 0.18),
+      controlPoint1: CGPoint(x: s * 0.28, y: s * 0.02),
+      controlPoint2: CGPoint(x: s * 0.52, y: s * 0.06)
+    )
+    path.curve(
+      to: CGPoint(x: s * 0.88, y: s * 0.55),
+      controlPoint1: CGPoint(x: s * 0.88, y: s * 0.28),
+      controlPoint2: CGPoint(x: s * 0.94, y: s * 0.42)
+    )
+    path.curve(
+      to: CGPoint(x: s * 0.42, y: s * 0.88),
+      controlPoint1: CGPoint(x: s * 0.80, y: s * 0.72),
+      controlPoint2: CGPoint(x: s * 0.58, y: s * 0.90)
+    )
+    path.curve(
+      to: CGPoint(x: s * 0.18, y: s * 0.48),
+      controlPoint1: CGPoint(x: s * 0.26, y: s * 0.86),
+      controlPoint2: CGPoint(x: s * 0.12, y: s * 0.68)
+    )
+    path.curve(
+      to: CGPoint(x: s * 0.12, y: s * 0.10),
+      controlPoint1: CGPoint(x: s * 0.22, y: s * 0.32),
+      controlPoint2: CGPoint(x: s * 0.08, y: s * 0.20)
+    )
+    path.close()
+    return path
+  }
+
+  func flashClick(duration: TimeInterval = 0.2) {
+    rippleTimer?.invalidate()
+    rippleVisible = true
+    rippleProgress = 0
+    fillPulse = 1
+    needsDisplay = true
+
+    let start = Date()
+    rippleTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 60.0, repeats: true) { [weak self] timer in
+      guard let self else {
+        timer.invalidate()
+        return
+      }
+      let t = min(1, Date().timeIntervalSince(start) / duration)
+      self.rippleProgress = CGFloat(t)
+      self.fillPulse = CGFloat(1 - t)
+      self.needsDisplay = true
+      if t >= 1 {
+        timer.invalidate()
+        self.rippleVisible = false
+        self.fillPulse = 0
+        self.needsDisplay = true
+      }
+    }
+    if let rippleTimer {
+      RunLoop.main.add(rippleTimer, forMode: .common)
+    }
+  }
+}
+
+// MARK: - Overlay window
+
+private final class NonActivatingWindow: NSWindow {
+  override var canBecomeKey: Bool { false }
+  override var canBecomeMain: Bool { false }
+}
+
+private final class OverlayController {
+  static let shared = OverlayController()
+
+  private var window: NonActivatingWindow?
+  private var pointerView: JianPointerView?
+  /// Current tip/hotspot in global top-left Quartz coordinates.
+  private var tipPoint = CGPoint.zero
+
+  private init() {}
+
+  private func ensureWindow() {
+    if window != nil { return }
+
+    let view = JianPointerView(frame: NSRect(x: 0, y: 0, width: pointerSize, height: pointerSize))
+    view.wantsLayer = true
+
+    let win = NonActivatingWindow(
+      contentRect: NSRect(x: 0, y: 0, width: pointerSize, height: pointerSize),
+      styleMask: .borderless,
+      backing: .buffered,
+      defer: false
+    )
+    win.isOpaque = false
+    win.backgroundColor = .clear
+    win.hasShadow = false
+    win.level = .statusBar
+    win.ignoresMouseEvents = true
+    win.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
+    win.isReleasedWhenClosed = false
+    win.contentView = view
+    win.alphaValue = 0
+    win.orderOut(nil)
+
+    pointerView = view
+    window = win
+  }
+
+  func ensureSession() {
+    ensureWindow()
+    guard let window else { return }
+    window.alphaValue = sessionAlpha
+    positionWindow()
+    window.orderFrontRegardless()
+  }
+
+  func setIdle() {
+    ensureWindow()
+    guard let window else { return }
+    window.alphaValue = idleAlpha
+    positionWindow()
+    window.orderFrontRegardless()
+  }
+
+  func endSession() {
+    guard let window else { return }
+    window.orderOut(nil)
+    window.alphaValue = 0
+  }
+
+  func moveTip(to globalTopLeft: CGPoint) {
+    tipPoint = globalTopLeft
+    ensureWindow()
+    positionWindow()
+  }
+
+  func flashClick() {
+    ensureWindow()
+    pointerView?.flashClick()
+  }
+
+  func currentTip() -> CGPoint { tipPoint }
+
+  private func positionWindow() {
+    guard let window else { return }
+    // Quartz global: origin top-left of primary, Y down. Cocoa: origin bottom-left, Y up.
+    let mainHeight = NSScreen.screens.first?.frame.height ?? NSScreen.main?.frame.height ?? 0
+    let tipCocoaY = mainHeight - tipPoint.y
+    // Window origin is bottom-left; hotspot is hotspot.y down from the top of the view.
+    let origin = NSPoint(
+      x: tipPoint.x - hotspot.x,
+      y: tipCocoaY - (pointerSize - hotspot.y)
+    )
+    window.setFrameOrigin(origin)
+  }
+}
+
+// MARK: - Coordinate helpers
+
+private func cgPointFromTopLeft(_ x: Double, _ y: Double) -> CGPoint {
+  CGPoint(x: x, y: y)
+}
+
+// MARK: - Mouse / keyboard
+
+private func postMouseMove(to point: CGPoint) {
+  OverlayController.shared.moveTip(to: point)
+  guard let event = CGEvent(
+    mouseEventSource: nil,
+    mouseType: .mouseMoved,
+    mouseCursorPosition: point,
+    mouseButton: .left
+  ) else {
+    logError("could not create mouseMoved event")
+    return
+  }
+  event.post(tap: .cghidEventTap)
+}
+
+private func postMouseClick(button: CGMouseButton, count: Int64) {
+  OverlayController.shared.flashClick()
+  let point = OverlayController.shared.currentTip()
+  let downType: CGEventType = button == .right ? .rightMouseDown : .leftMouseDown
+  let upType: CGEventType = button == .right ? .rightMouseUp : .leftMouseUp
+
+  for clickIndex in 1...max(1, count) {
+    if let down = CGEvent(
+      mouseEventSource: nil,
+      mouseType: downType,
+      mouseCursorPosition: point,
+      mouseButton: button
+    ) {
+      down.setIntegerValueField(.mouseEventClickState, value: clickIndex)
+      down.post(tap: .cghidEventTap)
+    }
+    if let up = CGEvent(
+      mouseEventSource: nil,
+      mouseType: upType,
+      mouseCursorPosition: point,
+      mouseButton: button
+    ) {
+      up.setIntegerValueField(.mouseEventClickState, value: clickIndex)
+      up.post(tap: .cghidEventTap)
+    }
+    if clickIndex < count {
+      Thread.sleep(forTimeInterval: 0.05)
+    }
+  }
+}
+
+private func postDrag(from: CGPoint, to: CGPoint) {
+  postMouseMove(to: from)
+  OverlayController.shared.flashClick()
+  Thread.sleep(forTimeInterval: 0.02)
+
+  if let down = CGEvent(
+    mouseEventSource: nil,
+    mouseType: .leftMouseDown,
+    mouseCursorPosition: from,
+    mouseButton: .left
+  ) {
+    down.post(tap: .cghidEventTap)
+  }
+
+  let steps = 12
+  for i in 1...steps {
+    let t = CGFloat(i) / CGFloat(steps)
+    let p = CGPoint(
+      x: from.x + (to.x - from.x) * t,
+      y: from.y + (to.y - from.y) * t
+    )
+    OverlayController.shared.moveTip(to: p)
+    if let drag = CGEvent(
+      mouseEventSource: nil,
+      mouseType: .leftMouseDragged,
+      mouseCursorPosition: p,
+      mouseButton: .left
+    ) {
+      drag.post(tap: .cghidEventTap)
+    }
+    Thread.sleep(forTimeInterval: 0.008)
+  }
+
+  if let up = CGEvent(
+    mouseEventSource: nil,
+    mouseType: .leftMouseUp,
+    mouseCursorPosition: to,
+    mouseButton: .left
+  ) {
+    up.post(tap: .cghidEventTap)
+  }
+  OverlayController.shared.moveTip(to: to)
+}
+
+private func postScroll(at point: CGPoint, direction: String, amount: Int) {
+  postMouseMove(to: point)
+  let n = max(1, amount)
+  var dx = 0
+  var dy = 0
+  switch direction {
+  case "up": dy = 1
+  case "down": dy = -1
+  case "left": dx = 1
+  case "right": dx = -1
+  default:
+    logError("unknown scroll direction: \(direction)")
+    return
+  }
+  for _ in 0..<n {
+    if let event = CGEvent(
+      scrollWheelEvent2Source: nil,
+      units: .line,
+      wheelCount: 2,
+      wheel1: Int32(dy),
+      wheel2: Int32(dx),
+      wheel3: 0
+    ) {
+      event.post(tap: .cghidEventTap)
+    }
+    Thread.sleep(forTimeInterval: 0.02)
+  }
+}
+
+// MARK: - Keycodes (US ANSI)
+
+private let letterKeyCodes: [Character: CGKeyCode] = [
+  "a": CGKeyCode(kVK_ANSI_A), "b": CGKeyCode(kVK_ANSI_B), "c": CGKeyCode(kVK_ANSI_C),
+  "d": CGKeyCode(kVK_ANSI_D), "e": CGKeyCode(kVK_ANSI_E), "f": CGKeyCode(kVK_ANSI_F),
+  "g": CGKeyCode(kVK_ANSI_G), "h": CGKeyCode(kVK_ANSI_H), "i": CGKeyCode(kVK_ANSI_I),
+  "j": CGKeyCode(kVK_ANSI_J), "k": CGKeyCode(kVK_ANSI_K), "l": CGKeyCode(kVK_ANSI_L),
+  "m": CGKeyCode(kVK_ANSI_M), "n": CGKeyCode(kVK_ANSI_N), "o": CGKeyCode(kVK_ANSI_O),
+  "p": CGKeyCode(kVK_ANSI_P), "q": CGKeyCode(kVK_ANSI_Q), "r": CGKeyCode(kVK_ANSI_R),
+  "s": CGKeyCode(kVK_ANSI_S), "t": CGKeyCode(kVK_ANSI_T), "u": CGKeyCode(kVK_ANSI_U),
+  "v": CGKeyCode(kVK_ANSI_V), "w": CGKeyCode(kVK_ANSI_W), "x": CGKeyCode(kVK_ANSI_X),
+  "y": CGKeyCode(kVK_ANSI_Y), "z": CGKeyCode(kVK_ANSI_Z),
+]
+
+private let digitKeyCodes: [Character: CGKeyCode] = [
+  "0": CGKeyCode(kVK_ANSI_0), "1": CGKeyCode(kVK_ANSI_1), "2": CGKeyCode(kVK_ANSI_2),
+  "3": CGKeyCode(kVK_ANSI_3), "4": CGKeyCode(kVK_ANSI_4), "5": CGKeyCode(kVK_ANSI_5),
+  "6": CGKeyCode(kVK_ANSI_6), "7": CGKeyCode(kVK_ANSI_7), "8": CGKeyCode(kVK_ANSI_8),
+  "9": CGKeyCode(kVK_ANSI_9),
+]
+
+private let namedKeyCodes: [String: CGKeyCode] = [
+  "return": CGKeyCode(kVK_Return),
+  "enter": CGKeyCode(kVK_Return),
+  "tab": CGKeyCode(kVK_Tab),
+  "escape": CGKeyCode(kVK_Escape),
+  "esc": CGKeyCode(kVK_Escape),
+  "delete": CGKeyCode(kVK_ForwardDelete),
+  "backspace": CGKeyCode(kVK_Delete),
+  "space": CGKeyCode(kVK_Space),
+  "up": CGKeyCode(kVK_UpArrow),
+  "down": CGKeyCode(kVK_DownArrow),
+  "left": CGKeyCode(kVK_LeftArrow),
+  "right": CGKeyCode(kVK_RightArrow),
+  "home": CGKeyCode(kVK_Home),
+  "end": CGKeyCode(kVK_End),
+  "pageup": CGKeyCode(kVK_PageUp),
+  "pagedown": CGKeyCode(kVK_PageDown),
+]
+
+private func postKeyCode(_ keyCode: CGKeyCode, flags: CGEventFlags = []) {
+  guard let down = CGEvent(keyboardEventSource: nil, virtualKey: keyCode, keyDown: true),
+    let up = CGEvent(keyboardEventSource: nil, virtualKey: keyCode, keyDown: false)
+  else {
+    logError("could not create keyboard event for keyCode \(keyCode)")
+    return
+  }
+  down.flags = flags
+  up.flags = flags
+  down.post(tap: .cghidEventTap)
+  up.post(tap: .cghidEventTap)
+}
+
+private func postUnicodeChar(_ scalar: UniChar) {
+  var chars = [scalar]
+  guard let down = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: true),
+    let up = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: false)
+  else {
+    logError("could not create unicode keyboard event")
+    return
+  }
+  down.keyboardSetUnicodeString(stringLength: 1, unicodeString: &chars)
+  up.keyboardSetUnicodeString(stringLength: 1, unicodeString: &chars)
+  down.post(tap: .cghidEventTap)
+  up.post(tap: .cghidEventTap)
+}
+
+private func typeText(_ text: String) {
+  // Iterate UTF-16 code units; map Return/Tab to virtual keys when present as characters.
+  let utf16 = Array(text.utf16)
+  var i = 0
+  while i < utf16.count {
+    let unit = utf16[i]
+    if unit == 0x000A || unit == 0x000D {
+      postKeyCode(CGKeyCode(kVK_Return))
+      if unit == 0x000D, i + 1 < utf16.count, utf16[i + 1] == 0x000A {
+        i += 1
+      }
+    } else if unit == 0x0009 {
+      postKeyCode(CGKeyCode(kVK_Tab))
+    } else {
+      postUnicodeChar(unit)
+    }
+    i += 1
+    Thread.sleep(forTimeInterval: 0.005)
+  }
+}
+
+private func parseAndPostKey(_ keySpec: String) -> Bool {
+  let parts = keySpec.split(separator: "+").map { $0.trimmingCharacters(in: .whitespaces).lowercased() }
+  guard !parts.isEmpty else { return false }
+
+  var flags: CGEventFlags = []
+  var keyToken: String?
+
+  for part in parts {
+    switch part {
+    case "cmd", "command", "meta", "super":
+      flags.insert(.maskCommand)
+    case "ctrl", "control":
+      flags.insert(.maskControl)
+    case "alt", "option", "opt":
+      flags.insert(.maskAlternate)
+    case "shift":
+      flags.insert(.maskShift)
+    default:
+      if keyToken != nil {
+        logError("ambiguous key chord: \(keySpec)")
+        return false
+      }
+      keyToken = part
+    }
+  }
+
+  guard let token = keyToken else {
+    logError("key chord has no key: \(keySpec)")
+    return false
+  }
+
+  if let named = namedKeyCodes[token] {
+    postKeyCode(named, flags: flags)
+    return true
+  }
+
+  if token.count == 1, let ch = token.first {
+    if let code = letterKeyCodes[ch] {
+      postKeyCode(code, flags: flags)
+      return true
+    }
+    if let code = digitKeyCodes[ch] {
+      postKeyCode(code, flags: flags)
+      return true
+    }
+  }
+
+  // Function keys F1–F12
+  if token.hasPrefix("f"), let n = Int(token.dropFirst()), (1...12).contains(n) {
+    let base = kVK_F1
+    postKeyCode(CGKeyCode(base + (n - 1)), flags: flags)
+    return true
+  }
+
+  logError("unknown key: \(keySpec)")
+  return false
+}
+
+// MARK: - Geometry
+
+private func geometryResponse() -> [String: Any] {
+  let screen = NSScreen.screens.first ?? NSScreen.main
+  guard let screen else {
+    return ["ok": false, "error": "no display available"]
+  }
+  let frame = screen.frame
+  let scale = screen.backingScaleFactor
+  // Primary display: Cocoa origin is bottom-left of main screen; Quartz global top-left origin is (0,0).
+  return [
+    "ok": true,
+    "originX": 0,
+    "originY": 0,
+    "pointWidth": frame.width,
+    "pointHeight": frame.height,
+    "pixelWidth": frame.width * scale,
+    "pixelHeight": frame.height * scale,
+    "scaleFactor": scale,
+  ]
+}
+
+// MARK: - Command dispatch
+
+private func handleCommand(_ object: [String: Any]) {
+  guard let cmd = object["cmd"] as? String else {
+    writeError("missing cmd")
+    return
+  }
+
+  switch cmd {
+  case "ping":
+    writeOk()
+
+  case "geometry":
+    writeResponse(geometryResponse())
+
+  case "ensureSession":
+    OverlayController.shared.ensureSession()
+    writeOk()
+
+  case "setIdle":
+    OverlayController.shared.setIdle()
+    writeOk()
+
+  case "endSession":
+    OverlayController.shared.endSession()
+    writeOk()
+
+  case "move":
+    guard let x = doubleValue(object, "pointX"), let y = doubleValue(object, "pointY") else {
+      writeError("move requires pointX and pointY")
+      return
+    }
+    postMouseMove(to: cgPointFromTopLeft(x, y))
+    writeOk()
+
+  case "click":
+    let buttonName = (object["button"] as? String ?? "left").lowercased()
+    let count = Int64(intValue(object, "count") ?? 1)
+    let button: CGMouseButton
+    switch buttonName {
+    case "left": button = .left
+    case "right": button = .right
+    default:
+      writeError("button must be left or right")
+      return
+    }
+    if count != 1 && count != 2 {
+      writeError("count must be 1 or 2")
+      return
+    }
+    postMouseClick(button: button, count: count)
+    writeOk()
+
+  case "drag":
+    guard let fromX = doubleValue(object, "fromX"),
+      let fromY = doubleValue(object, "fromY"),
+      let toX = doubleValue(object, "toX"),
+      let toY = doubleValue(object, "toY")
+    else {
+      writeError("drag requires fromX, fromY, toX, toY")
+      return
+    }
+    postDrag(from: cgPointFromTopLeft(fromX, fromY), to: cgPointFromTopLeft(toX, toY))
+    writeOk()
+
+  case "type":
+    guard let text = object["text"] as? String else {
+      writeError("type requires text")
+      return
+    }
+    typeText(text)
+    writeOk()
+
+  case "key":
+    guard let key = object["key"] as? String else {
+      writeError("key requires key")
+      return
+    }
+    if parseAndPostKey(key) {
+      writeOk()
+    } else {
+      writeError("unrecognized key: \(key)")
+    }
+
+  case "scroll":
+    guard let x = doubleValue(object, "pointX"),
+      let y = doubleValue(object, "pointY"),
+      let direction = object["direction"] as? String,
+      let amount = intValue(object, "amount")
+    else {
+      writeError("scroll requires pointX, pointY, direction, amount")
+      return
+    }
+    let dir = direction.lowercased()
+    guard ["up", "down", "left", "right"].contains(dir) else {
+      writeError("direction must be up, down, left, or right")
+      return
+    }
+    postScroll(at: cgPointFromTopLeft(x, y), direction: dir, amount: amount)
+    writeOk()
+
+  default:
+    writeError("unknown cmd: \(cmd)")
+  }
+}
+
+// MARK: - Stdin reader + main
+
+private final class StdinReader {
+  private let queue = DispatchQueue(label: "com.jian.computer-helper.stdin")
+
+  func start() {
+    queue.async {
+      let handle = FileHandle.standardInput
+      var buffer = Data()
+      while true {
+        let chunk = handle.availableData
+        if chunk.isEmpty {
+          // EOF — exit the process cleanly.
+          DispatchQueue.main.async {
+            NSApp.terminate(nil)
+          }
+          return
+        }
+        buffer.append(chunk)
+        while let range = buffer.range(of: Data([0x0A])) {
+          let lineData = buffer.subdata(in: buffer.startIndex..<range.lowerBound)
+          buffer.removeSubrange(buffer.startIndex...range.lowerBound)
+          if let line = String(data: lineData, encoding: .utf8) {
+            let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
+            if trimmed.isEmpty { continue }
+            DispatchQueue.main.async {
+              if let object = parseJSONLine(trimmed) {
+                handleCommand(object)
+              } else {
+                logError("invalid JSON line")
+                writeError("invalid JSON")
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+private let stdinReader = StdinReader()
+
+autoreleasepool {
+  let app = NSApplication.shared
+  app.setActivationPolicy(.accessory)
+  stdinReader.start()
+  app.run()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jian-ai/remote-control",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Jian Remote Control worker — connect a computer to a Jian gateway over HTTPS",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
   },
   "files": [
     "bin",
+    "macos",
     "README.md"
   ],
   "engines": {