@swipt/cli 0.1.0-nightly.32 → 0.1.0-nightly.34

package/client.mjs

@@ -0,0 +1,298 @@
+import dns from "node:dns";
+
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+
+import { LogService } from "./proto/logs_pb.js";
+import { REPLService } from "./proto/repl_pb.js";
+import { SwipletService } from "./proto/swiplets_pb.js";
+import { SystemService } from "./proto/system_pb.js";
+
+const largestMessage = 128 << 20;
+const contentType = "application/grpc-web+proto";
+const webSocketSubprotocol = "grpc-websockets";
+
+dns.setDefaultResultOrder("ipv4first");
+
+export const Code = {
+  Canceled: 1,
+  Unknown: 2,
+  DeadlineExceeded: 4,
+  NotFound: 5,
+  Unimplemented: 12,
+  Internal: 13,
+  Unavailable: 14,
+  Unauthenticated: 16,
+};
+
+export class UsageError extends Error {}
+
+export class RpcError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+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) {
+    return "";
+  }
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+
+const transportError = error => {
+  if (error instanceof RpcError) {
+    return error;
+  }
+  if (error?.name === "AbortError") {
+    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));
+};
+
+function frame(schema, init) {
+  const body = toBinary(schema, create(schema, init));
+  const out = Buffer.allocUnsafe(5 + body.length);
+  out[0] = 0;
+  out.writeUInt32BE(body.length, 1);
+  out.set(body, 5);
+  return out;
+}
+
+function parseMetadata(body) {
+  const headers = {};
+  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();
+    }
+  }
+  return headers;
+}
+
+class FrameReader {
+  pending = Buffer.alloc(0);
+
+  constructor(schema) {
+    this.schema = schema;
+  }
+
+  push(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`);
+      }
+      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) });
+      this.pending = this.pending.subarray(5 + length);
+    }
+    return frames;
+  }
+}
+
+function checkStatus(headers) {
+  const status = headers["grpc-status"];
+  if (status === undefined || status === null) {
+    return false;
+  }
+  const code = Number(status);
+  if (code !== 0) {
+    throw new RpcError(code, statusMessage(headers["grpc-message"]));
+  }
+  return true;
+}
+
+function requestHeaders(connection) {
+  const headers = { "content-type": contentType, "x-grpc-web": "1" };
+  if (connection.token !== "") {
+    headers.authorization = `Bearer ${connection.token}`;
+  }
+  return headers;
+}
+
+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,
+    });
+  } 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}`);
+  }
+  if (checkStatus(headers)) {
+    await response.body?.cancel();
+    return;
+  }
+  const reader = new FrameReader(method.output);
+  let ended = false;
+  try {
+    for await (const chunk of response.body) {
+      for (const found of reader.push(chunk)) {
+        if (found.trailers) {
+          checkStatus(found.trailers);
+          ended = true;
+        } else if (!ended) {
+          yield found.message;
+        }
+      }
+    }
+  } catch (error) {
+    throw transportError(error);
+  }
+  if (!ended) {
+    throw new RpcError(Code.Unavailable, "the response ended without a status");
+  }
+}
+
+async function* invokeWebSocket(connection, method, input, { signal }) {
+  const socket = new WebSocket(`${connection.webSocketBase}/${method.parent.typeName}/${method.name}`, [webSocketSubprotocol]);
+  socket.binaryType = "arraybuffer";
+  const reader = new FrameReader(method.output);
+  const messages = [];
+  let failure;
+  let closed = false;
+  let headersSeen = false;
+  let wake = () => {};
+  const notify = () => {
+    const current = wake;
+    wake = () => {};
+    current();
+  };
+  const fail = error => {
+    failure ??= error;
+    socket.close();
+    notify();
+  };
+  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("message", event => {
+    try {
+      for (const found of reader.push(new Uint8Array(event.data))) {
+        if (found.message) {
+          messages.push(found.message);
+        } else if (headersSeen || "grpc-status" in found.trailers) {
+          checkStatus(found.trailers);
+          closed = true;
+          socket.close();
+        } else {
+          headersSeen = true;
+        }
+      }
+    } catch (error) {
+      fail(error);
+    }
+    notify();
+  });
+  socket.addEventListener("close", event => {
+    if (!closed) {
+      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}`);
+  });
+  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("")}`));
+    const sender = (async () => {
+      try {
+        const body = method.methodKind === "client_streaming" ? input : [input];
+        for await (const message of body) {
+          if (closed) {
+            return;
+          }
+          socket.send(Buffer.concat([Buffer.from([0]), frame(method.input, message)]));
+        }
+        if (!closed) {
+          socket.send(Buffer.from([1]));
+        }
+      } catch (error) {
+        fail(transportError(error));
+      }
+    })();
+    while (true) {
+      if (messages.length > 0) {
+        yield messages.shift();
+        continue;
+      }
+      if (closed) {
+        break;
+      }
+      await new Promise(resolve => {
+        wake = resolve;
+      });
+    }
+    await sender;
+    if (failure) {
+      throw failure;
+    }
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    if (socket.readyState !== WebSocket.CLOSED) {
+      socket.close();
+    }
+  }
+}
+
+async function single(iterable) {
+  let found;
+  for await (const message of iterable) {
+    found ??= message;
+  }
+  if (found === undefined) {
+    throw new RpcError(Code.Internal, "the server sent no response");
+  }
+  return found;
+}
+
+function bind(service, connection) {
+  const client = {};
+  for (const method of service.methods) {
+    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;
+    };
+  }
+  return client;
+}
+
+export function open({ url, token }) {
+  const connection = { token, base: url, webSocketBase: url.replace(/^http/, "ws") };
+  return {
+    system: bind(SystemService, connection),
+    logs: bind(LogService, connection),
+    swiplets: bind(SwipletService, connection),
+    repl: bind(REPLService, connection),
+  };
+}
+
+export const unauthenticated = error => error instanceof RpcError && error.code === Code.Unauthenticated;

package/connection.mjs

@@ -0,0 +1,227 @@
+import dgram from "node:dgram";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+
+import Bonjour from "bonjour-service";
+
+import { Code, RpcError, UsageError, open } from "./client.mjs";
+import { columns } from "./output.mjs";
+
+const browseLimit = 1500;
+const browseRequery = 300;
+
+const storeFile = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "swipt", "devices.json");
+
+function load() {
+  let text;
+  try {
+    text = fs.readFileSync(storeFile, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+  return JSON.parse(text);
+}
+
+function save(devices) {
+  fs.mkdirSync(path.dirname(storeFile), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(storeFile, `${JSON.stringify(devices, null, 2)}\n`, { mode: 0o600 });
+}
+
+function label(name) {
+  const slug = [...name.replaceAll(/['’]/g, "")]
+    .map(character => (/[A-Za-z0-9]/.test(character) ? character : "-"))
+    .join("")
+    .split("-")
+    .filter(part => part !== "")
+    .join("-");
+  return slug === "" ? name : slug;
+}
+
+const sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+
+const storedName = (stored, name) => Object.keys(stored).find(it => sameName(it, name));
+
+function parseURL(text) {
+  let parsed;
+  try {
+    parsed = new URL(text.includes("://") ? text : `http://${text}`);
+  } catch {
+    throw new UsageError(`${text} is not a URL`);
+  }
+  if (parsed.hostname === "" || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+    throw new UsageError(`${text} is not an http or https URL`);
+  }
+  let token;
+  try {
+    token = decodeURIComponent(parsed.username);
+  } catch {
+    token = parsed.username;
+  }
+  return { url: `${parsed.protocol}//${parsed.host}${parsed.pathname.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 found = new Map();
+  const enough = new AbortController();
+  try {
+    const browser = bonjour.find({ type: "swipt" }, service => {
+      if (!service.host || found.has(service.name)) {
+        return;
+      }
+      const host = service.host.replace(/\.$/, "").toLowerCase();
+      found.set(service.name, {
+        name: label(service.name),
+        url: `http://${host.includes(":") ? `[${host}]` : host}:${service.port}`,
+        authenticates: service.txt?.auth === "1",
+      });
+      if (until?.([...found.values()])) {
+        enough.abort();
+      }
+    });
+    const requery = setInterval(() => browser.update(), browseRequery);
+    try {
+      await sleep(browseLimit, undefined, { signal: AbortSignal.any([signal, enough.signal]) });
+    } catch (error) {
+      if (signal.aborted) {
+        throw error;
+      }
+    } finally {
+      clearInterval(requery);
+    }
+    browser.stop();
+  } finally {
+    bonjour.destroy();
+  }
+  return [...found.values()];
+}
+
+async function discover(signal, stored, until) {
+  const found = await browse(signal, until);
+  let changed = false;
+  for (const it of found) {
+    if (it.authenticates) {
+      continue;
+    }
+    const name = storedName(stored, it.name);
+    if (name === undefined) {
+      stored[it.name] = it.url;
+      changed = true;
+    } else {
+      const current = parseURL(stored[name]);
+      if (current.token === "" && current.url !== it.url) {
+        stored[name] = it.url;
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    save(stored);
+  }
+  return found;
+}
+
+const requiresToken = found => `${found.name} requires a token: swipt connect ${withToken(found.url)}`;
+
+export async function attach(context) {
+  const given = context.options.device ?? process.env.SWIPT_DEVICE;
+  const stored = load();
+  let device;
+  if (given && /[:/]/.test(given)) {
+    device = parseURL(given);
+  } else if (given) {
+    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));
+      if (!found) {
+        throw new Error(`there is no device ${name}; "swipt devices" lists them`);
+      }
+      if (found.authenticates) {
+        throw new Error(requiresToken(found));
+      }
+      known = found.name;
+    }
+    device = parseURL(stored[known]);
+  } else {
+    let found = [];
+    if (Object.keys(stored).length === 0) {
+      found = await discover(context.signal, stored);
+    }
+    const names = Object.keys(stored);
+    if (names.length === 0) {
+      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 connect URL"');
+    }
+    if (names.length > 1) {
+      throw new Error(`there is more than one device: ${names.join(", ")}; choose one with -d or SWIPT_DEVICE`);
+    }
+    device = parseURL(stored[names[0]]);
+  }
+  context.target.url = device.url;
+  return open(device);
+}
+
+async function reachable(device, signal) {
+  try {
+    await open(device).system.getInfo({}, { signal });
+    return true;
+  } catch (error) {
+    return error instanceof RpcError && error.code === Code.Unauthenticated;
+  }
+}
+
+export async function devices({ signal }) {
+  const stored = load();
+  const deadline = AbortSignal.any([signal, AbortSignal.timeout(browseLimit)]);
+  const probes = new Map(Object.entries(stored).map(([name, url]) => [name, reachable(parseURL(url), deadline)]));
+  const found = 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 connect URL"');
+    return;
+  }
+  const rows = [];
+  for (const name of names) {
+    const { url } = parseURL(stored[name]);
+    const online = found.some(it => sameName(it.name, name) && it.url === url) || (probes.has(name) && (await probes.get(name)));
+    rows.push([name, url, online ? "" : "offline"]);
+  }
+  console.log(columns(rows));
+}
+
+export async function connect(context) {
+  const device = parseURL(context.args[0]);
+  context.target.url = device.url;
+  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);
+  if (previous !== undefined) {
+    delete stored[previous];
+  }
+  stored[name] = context.args[0];
+  save(stored);
+  console.log("connected", name);
+}
+
+export function disconnect({ args }) {
+  const stored = load();
+  const name = storedName(stored, label(args[0]));
+  if (name === undefined) {
+    throw new Error(`there is no device ${args[0]}`);
+  }
+  delete stored[name];
+  save(stored);
+  console.log("disconnected", name);
+}