@swipt/cli 0.1.0-nightly.43 → 0.1.0-nightly.45

package/client.mjs

@@ -33,7 +33,16 @@ export class RpcError extends Error {
   }
 }
 
-const httpStatusCodes = { 400: Code.Internal, 401: Code.Unauthenticated, 403: Code.Unauthenticated, 404: Code.Unimplemented, 429: Code.Unavailable, 502: Code.Unavailable, 503: Code.Unavailable, 504: Code.Unavailable };
+const httpStatusCodes = {
+  400: Code.Internal,
+  401: Code.Unauthenticated,
+  403: Code.Unauthenticated,
+  404: Code.Unimplemented,
+  429: Code.Unavailable,
+  502: Code.Unavailable,
+  503: Code.Unavailable,
+  504: Code.Unavailable,
+};
 
 function statusMessage(text) {
   if (text === undefined || text === null) {
@@ -46,7 +55,7 @@ function statusMessage(text) {
   }
 }
 
-const transportError = error => {
+const transportError = (error) => {
   if (error instanceof RpcError) {
     return error;
   }
@@ -54,7 +63,10 @@ const transportError = error => {
     return new RpcError(Code.Canceled, "the call was canceled");
   }
   const cause = error?.cause;
-  return new RpcError(Code.Unavailable, cause?.message || cause?.code || error?.message || String(error));
+  return new RpcError(
+    Code.Unavailable,
+    cause?.message || cause?.code || error?.message || String(error),
+  );
 };
 
 function frame(schema, init) {
@@ -71,7 +83,9 @@ function parseMetadata(body) {
   for (const line of Buffer.from(body).toString().split("\r\n")) {
     const separator = line.indexOf(":");
     if (separator > 0) {
-      headers[line.slice(0, separator).trim().toLowerCase()] = line.slice(separator + 1).trim();
+      headers[line.slice(0, separator).trim().toLowerCase()] = line
+        .slice(separator + 1)
+        .trim();
     }
   }
   return headers;
@@ -85,18 +99,28 @@ class FrameReader {
   }
 
   push(chunk) {
-    this.pending = this.pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.pending, Buffer.from(chunk)]);
+    this.pending =
+      this.pending.length === 0
+        ? Buffer.from(chunk)
+        : Buffer.concat([this.pending, Buffer.from(chunk)]);
     const frames = [];
     while (this.pending.length >= 5) {
       const length = this.pending.readUInt32BE(1);
       if (length > largestMessage) {
-        throw new RpcError(Code.Internal, `the server sent a message of ${length} bytes`);
+        throw new RpcError(
+          Code.Internal,
+          `the server sent a message of ${length} bytes`,
+        );
       }
       if (this.pending.length < 5 + length) {
         break;
       }
       const body = this.pending.subarray(5, 5 + length);
-      frames.push((this.pending[0] & 0x80) !== 0 ? { trailers: parseMetadata(body) } : { message: fromBinary(this.schema, body) });
+      frames.push(
+        (this.pending[0] & 0x80) !== 0
+          ? { trailers: parseMetadata(body) }
+          : { message: fromBinary(this.schema, body) },
+      );
       this.pending = this.pending.subarray(5 + length);
     }
     return frames;
@@ -126,19 +150,25 @@ function requestHeaders(connection) {
 async function* invokeHTTP(connection, method, input, { signal }) {
   let response;
   try {
-    response = await fetch(`${connection.base}/${method.parent.typeName}/${method.name}`, {
-      method: "POST",
-      headers: requestHeaders(connection),
-      body: frame(method.input, input),
-      signal,
-    });
+    response = await fetch(
+      `${connection.base}/${method.parent.typeName}/${method.name}`,
+      {
+        method: "POST",
+        headers: requestHeaders(connection),
+        body: frame(method.input, input),
+        signal,
+      },
+    );
   } catch (error) {
     throw transportError(error);
   }
   const headers = Object.fromEntries(response.headers);
   if (response.status !== 200) {
     await response.body?.cancel();
-    throw new RpcError(httpStatusCodes[response.status] ?? Code.Unknown, `HTTP ${response.status}`);
+    throw new RpcError(
+      httpStatusCodes[response.status] ?? Code.Unknown,
+      `HTTP ${response.status}`,
+    );
   }
   if (checkStatus(headers)) {
     await response.body?.cancel();
@@ -166,7 +196,10 @@ async function* invokeHTTP(connection, method, input, { signal }) {
 }
 
 async function* invokeWebSocket(connection, method, input, { signal }) {
-  const socket = new WebSocket(`${connection.webSocketBase}/${method.parent.typeName}/${method.name}`, [webSocketSubprotocol]);
+  const socket = new WebSocket(
+    `${connection.webSocketBase}/${method.parent.typeName}/${method.name}`,
+    [webSocketSubprotocol],
+  );
   socket.binaryType = "arraybuffer";
   const reader = new FrameReader(method.output);
   const messages = [];
@@ -179,17 +212,28 @@ async function* invokeWebSocket(connection, method, input, { signal }) {
     wake = () => {};
     current();
   };
-  const fail = error => {
+  const fail = (error) => {
     failure ??= error;
     socket.close();
     notify();
   };
-  const abort = () => fail(new RpcError(Code.Canceled, "the call was canceled"));
+  const abort = () =>
+    fail(new RpcError(Code.Canceled, "the call was canceled"));
   const opened = new Promise((resolve, reject) => {
     socket.addEventListener("open", resolve, { once: true });
-    socket.addEventListener("error", () => reject(new RpcError(Code.Unavailable, `cannot connect to ${connection.webSocketBase}`)), { once: true });
+    socket.addEventListener(
+      "error",
+      () =>
+        reject(
+          new RpcError(
+            Code.Unavailable,
+            `cannot connect to ${connection.webSocketBase}`,
+          ),
+        ),
+      { once: true },
+    );
   });
-  socket.addEventListener("message", event => {
+  socket.addEventListener("message", (event) => {
     try {
       for (const found of reader.push(new Uint8Array(event.data))) {
         if (found.message) {
@@ -207,21 +251,33 @@ async function* invokeWebSocket(connection, method, input, { signal }) {
     }
     notify();
   });
-  socket.addEventListener("close", event => {
+  socket.addEventListener("close", (event) => {
     if (!closed) {
-      failure ??= new RpcError(Code.Unavailable, event.reason || "the connection closed before the response");
+      failure ??= new RpcError(
+        Code.Unavailable,
+        event.reason || "the connection closed before the response",
+      );
     }
     closed = true;
     notify();
   });
   socket.addEventListener("error", () => {
-    failure ??= new RpcError(Code.Unavailable, `cannot connect to ${connection.webSocketBase}`);
+    failure ??= new RpcError(
+      Code.Unavailable,
+      `cannot connect to ${connection.webSocketBase}`,
+    );
   });
   signal?.addEventListener("abort", abort, { once: true });
   try {
     await opened;
     const headers = requestHeaders(connection);
-    socket.send(Buffer.from(`${Object.entries(headers).map(([key, value]) => `${key}: ${value}\r\n`).join("")}`));
+    socket.send(
+      Buffer.from(
+        `${Object.entries(headers)
+          .map(([key, value]) => `${key}: ${value}\r\n`)
+          .join("")}`,
+      ),
+    );
     const sender = (async () => {
       try {
         const body = method.methodKind === "client_streaming" ? input : [input];
@@ -229,7 +285,9 @@ async function* invokeWebSocket(connection, method, input, { signal }) {
           if (closed) {
             return;
           }
-          socket.send(Buffer.concat([Buffer.from([0]), frame(method.input, message)]));
+          socket.send(
+            Buffer.concat([Buffer.from([0]), frame(method.input, message)]),
+          );
         }
         if (!closed) {
           socket.send(Buffer.from([1]));
@@ -246,7 +304,7 @@ async function* invokeWebSocket(connection, method, input, { signal }) {
       if (closed) {
         break;
       }
-      await new Promise(resolve => {
+      await new Promise((resolve) => {
         wake = resolve;
       });
     }
@@ -276,17 +334,31 @@ async function single(iterable) {
 function bind(service, connection) {
   const client = {};
   for (const method of service.methods) {
-    const streamsInput = method.methodKind === "client_streaming" || method.methodKind === "bidi_streaming";
+    const streamsInput =
+      method.methodKind === "client_streaming" ||
+      method.methodKind === "bidi_streaming";
     client[method.localName] = (input, options = {}) => {
-      const call = (streamsInput ? invokeWebSocket : invokeHTTP)(connection, method, input, { signal: options.signal });
-      return method.methodKind === "unary" || method.methodKind === "client_streaming" ? single(call) : call;
+      const call = (streamsInput ? invokeWebSocket : invokeHTTP)(
+        connection,
+        method,
+        input,
+        { signal: options.signal },
+      );
+      return method.methodKind === "unary" ||
+        method.methodKind === "client_streaming"
+        ? single(call)
+        : call;
     };
   }
   return client;
 }
 
 export function open({ url, token }) {
-  const connection = { token, base: url, webSocketBase: url.replace(/^http/, "ws") };
+  const connection = {
+    token,
+    base: url,
+    webSocketBase: url.replace(/^http/, "ws"),
+  };
   return {
     system: bind(SystemService, connection),
     logs: bind(LogService, connection),
@@ -295,4 +367,5 @@ export function open({ url, token }) {
   };
 }
 
-export const unauthenticated = error => error instanceof RpcError && error.code === Code.Unauthenticated;
+export const unauthenticated = (error) =>
+  error instanceof RpcError && error.code === Code.Unauthenticated;

package/connection.mjs

@@ -8,12 +8,20 @@ import Bonjour from "bonjour-service";
 
 import { Code, RpcError, UsageError, open } from "./client.mjs";
 import { columns, enumText } from "./output.mjs";
-import { DeviceConnectionProblem, DeviceConnectionProblemSchema, DeviceConnectionStateSchema } from "./proto/common_pb.js";
+import {
+  DeviceConnectionProblem,
+  DeviceConnectionProblemSchema,
+  DeviceConnectionStateSchema,
+} from "./proto/common_pb.js";
 
 const browseLimit = 1500;
 const browseRequery = 300;
 
-const storeFile = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "swipt", "devices.json");
+const storeFile = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+  "swipt",
+  "devices.json",
+);
 
 function load() {
   let text;
@@ -30,22 +38,25 @@ function load() {
 
 function save(devices) {
   fs.mkdirSync(path.dirname(storeFile), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(storeFile, `${JSON.stringify(devices, null, 2)}\n`, { mode: 0o600 });
+  fs.writeFileSync(storeFile, `${JSON.stringify(devices, null, 2)}\n`, {
+    mode: 0o600,
+  });
 }
 
 export function label(name) {
   const slug = [...name.replaceAll(/['’]/g, "")]
-    .map(character => (/[A-Za-z0-9]/.test(character) ? character : "-"))
+    .map((character) => (/[A-Za-z0-9]/.test(character) ? character : "-"))
     .join("")
     .split("-")
-    .filter(part => part !== "")
+    .filter((part) => part !== "")
     .join("-");
   return slug === "" ? name : slug;
 }
 
 export const sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
 
-const storedName = (stored, name) => Object.keys(stored).find(it => sameName(it, name));
+const storedName = (stored, name) =>
+  Object.keys(stored).find((it) => sameName(it, name));
 
 function parseURL(text) {
   let parsed;
@@ -54,7 +65,10 @@ function parseURL(text) {
   } catch {
     throw new UsageError(`${text} is not a URL`);
   }
-  if (parsed.hostname === "" || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+  if (
+    parsed.hostname === "" ||
+    (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+  ) {
     throw new UsageError(`${text} is not an http or https URL`);
   }
   let token;
@@ -63,17 +77,23 @@ function parseURL(text) {
   } catch {
     token = parsed.username;
   }
-  return { url: `${parsed.protocol}//${parsed.host}${parsed.pathname.replace(/\/+$/, "")}`, token };
+  return {
+    url: `${parsed.protocol}//${parsed.host}${parsed.pathname.replace(/\/+$/, "")}`,
+    token,
+  };
 }
 
-export const withToken = url => url.replace("://", "://TOKEN@");
+export const withToken = (url) => url.replace("://", "://TOKEN@");
 
 async function browse(signal, until) {
-  const bonjour = new Bonjour({ socket: dgram.createSocket("udp4"), bind: false });
+  const bonjour = new Bonjour({
+    socket: dgram.createSocket("udp4"),
+    bind: false,
+  });
   const found = new Map();
   const enough = new AbortController();
   try {
-    const browser = bonjour.find({ type: "swipt" }, service => {
+    const browser = bonjour.find({ type: "swipt" }, (service) => {
       if (!service.host || found.has(service.name)) {
         return;
       }
@@ -89,7 +109,9 @@ async function browse(signal, until) {
     });
     const requery = setInterval(() => browser.update(), browseRequery);
     try {
-      await sleep(browseLimit, undefined, { signal: AbortSignal.any([signal, enough.signal]) });
+      await sleep(browseLimit, undefined, {
+        signal: AbortSignal.any([signal, enough.signal]),
+      });
     } catch (error) {
       if (signal.aborted) {
         throw error;
@@ -129,7 +151,8 @@ async function discover(signal, stored, until) {
   return found;
 }
 
-const requiresToken = found => `${found.name} requires a token: swipt device add ${withToken(found.url)}`;
+const requiresToken = (found) =>
+  `${found.name} requires a token: swipt device add ${withToken(found.url)}`;
 
 export async function attach(context) {
   const given = context.options.device ?? process.env.SWIPT_DEVICE;
@@ -141,9 +164,15 @@ export async function attach(context) {
     const name = label(given);
     let known = storedName(stored, name);
     if (known === undefined) {
-      const found = (await discover(context.signal, stored, services => services.some(it => sameName(it.name, name)))).find(it => sameName(it.name, name));
+      const found = (
+        await discover(context.signal, stored, (services) =>
+          services.some((it) => sameName(it.name, name)),
+        )
+      ).find((it) => sameName(it.name, name));
       if (!found) {
-        throw new Error(`there is no device ${name}; "swipt device list" lists them`);
+        throw new Error(
+          `there is no device ${name}; "swipt device list" lists them`,
+        );
       }
       if (found.authenticates) {
         throw new Error(requiresToken(found));
@@ -158,14 +187,18 @@ export async function attach(context) {
     }
     const names = Object.keys(stored);
     if (names.length === 0) {
-      const locked = found.filter(it => it.authenticates);
+      const locked = found.filter((it) => it.authenticates);
       if (locked.length > 0) {
         throw new Error(locked.map(requiresToken).join("\n"));
       }
-      throw new Error('there is no device; turn on Swipt › Developer › Local Network, or connect one with "swipt device add URL"');
+      throw new Error(
+        'there is no device; turn on Swipt › Developer › Local Network, or connect one with "swipt device add URL"',
+      );
     }
     if (names.length > 1) {
-      throw new Error(`there is more than one device: ${names.join(", ")}; choose one with -d or SWIPT_DEVICE`);
+      throw new Error(
+        `there is more than one device: ${names.join(", ")}; choose one with -d or SWIPT_DEVICE`,
+      );
     }
     device = parseURL(stored[names[0]]);
   }
@@ -174,8 +207,15 @@ export async function attach(context) {
 }
 
 function connectionText(connection) {
-  let text = enumText(DeviceConnectionStateSchema, connection?.state ?? 0, "DEVICE_CONNECTION_STATE_");
-  if (connection && connection.problem !== DeviceConnectionProblem.UNSPECIFIED) {
+  let text = enumText(
+    DeviceConnectionStateSchema,
+    connection?.state ?? 0,
+    "DEVICE_CONNECTION_STATE_",
+  );
+  if (
+    connection &&
+    connection.problem !== DeviceConnectionProblem.UNSPECIFIED
+  ) {
     text += `, ${enumText(DeviceConnectionProblemSchema, connection.problem, "DEVICE_CONNECTION_PROBLEM_")}`;
   }
   if (connection?.message) {
@@ -187,31 +227,51 @@ function connectionText(connection) {
 async function probe(url, signal) {
   try {
     const info = await open(parseURL(url)).system.getInfo({}, { signal });
-    return [`${info.appVersion} (${info.appBuild})`, connectionText(info.deviceConnection)];
+    return [
+      `${info.appVersion} (${info.appBuild})`,
+      connectionText(info.deviceConnection),
+    ];
   } catch (error) {
-    return [error instanceof RpcError && error.code === Code.Unauthenticated ? "requires a token" : "offline"];
+    return [
+      error instanceof RpcError && error.code === Code.Unauthenticated
+        ? "requires a token"
+        : "offline",
+    ];
   }
 }
 
 export async function list({ signal }) {
   const stored = load();
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(browseLimit)]);
-  const probes = new Map(Object.values(stored).map(url => [url, probe(url, deadline)]));
+  const probes = new Map(
+    Object.values(stored).map((url) => [url, probe(url, deadline)]),
+  );
   await discover(signal, stored);
   const names = Object.keys(stored).sort((a, b) => a.localeCompare(b));
   if (names.length === 0) {
-    console.error('no device publishes Swipt on the local network; turn on Swipt › Developer › Local Network, or connect one with "swipt device add URL"');
+    console.error(
+      'no device publishes Swipt on the local network; turn on Swipt › Developer › Local Network, or connect one with "swipt device add URL"',
+    );
     return;
   }
   const late = AbortSignal.any([signal, AbortSignal.timeout(browseLimit)]);
-  const rows = await Promise.all(names.map(async name => [name, parseURL(stored[name]).url, ...(await (probes.get(stored[name]) ?? probe(stored[name], late)))]));
+  const rows = await Promise.all(
+    names.map(async (name) => [
+      name,
+      parseURL(stored[name]).url,
+      ...(await (probes.get(stored[name]) ?? probe(stored[name], late))),
+    ]),
+  );
   console.log(columns(rows));
 }
 
 export async function add(context) {
   const device = parseURL(context.args[0]);
   context.target.url = device.url;
-  const info = await open(device).system.getInfo({}, { signal: context.signal });
+  const info = await open(device).system.getInfo(
+    {},
+    { signal: context.signal },
+  );
   const name = label(info.deviceName) || new URL(device.url).hostname;
   const stored = load();
   const previous = storedName(stored, name);

package/coredevice.mjs

@@ -0,0 +1,68 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { label, sameName } from "./connection.mjs";
+
+export function devicectl(args, { parse = false } = {}) {
+  const output = parse
+    ? path.join(os.tmpdir(), `devicectl-${process.pid}.json`)
+    : undefined;
+  const result = spawnSync(
+    "xcrun",
+    ["devicectl", ...args, ...(parse ? ["--json-output", output] : [])],
+    { encoding: "utf8" },
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const text = `${result.stdout}${result.stderr}`;
+    if (text.includes("4016")) {
+      throw new Error(
+        "CoreDevice cannot reach the device while its loopback VPN is on; turn off Swipt's VPN on the device, then run this again",
+      );
+    }
+    throw new Error(text.trim() || `devicectl exited with ${result.status}`);
+  }
+  if (!parse) {
+    return undefined;
+  }
+  const parsed = JSON.parse(fs.readFileSync(output, "utf8"));
+  fs.rmSync(output);
+  return parsed;
+}
+
+export function coreDevice(given) {
+  const devices = devicectl(["list", "devices"], { parse: true })
+    .result.devices.filter(
+      (device) =>
+        device.hardwareProperties.platform === "iOS" &&
+        device.hardwareProperties.reality === "physical",
+    )
+    .map((device) => ({
+      name: device.deviceProperties.name,
+      udid: device.hardwareProperties.udid,
+    }));
+  const matches = given
+    ? devices.filter(
+        (device) =>
+          sameName(device.udid, given) ||
+          sameName(label(device.name), label(given)),
+      )
+    : devices;
+  if (matches.length !== 1) {
+    const found = matches.length === 0 ? "no" : "more than one";
+    throw new Error(
+      given
+        ? `${found} iOS device is named ${given}`
+        : `${found} iOS device is paired; choose one with -d NAME|UDID`,
+    );
+  }
+  return matches[0];
+}
+
+export const apps = (udid) =>
+  devicectl(["device", "info", "apps", "--device", udid], { parse: true })
+    .result.apps;