@swipt/cli 0.1.0-nightly.33 → 0.1.0-nightly.35

package/client.mjs

@@ -1,3 +1,5 @@
+import dns from "node:dns";
+
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 
 import { LogService } from "./proto/logs_pb.js";
@@ -9,6 +11,8 @@ const largestMessage = 128 << 20;
 const contentType = "application/grpc-web+proto";
 const webSocketSubprotocol = "grpc-websockets";
 
+dns.setDefaultResultOrder("ipv4first");
+
 export const Code = {
   Canceled: 1,
   Unknown: 2,
@@ -111,23 +115,20 @@ function checkStatus(headers) {
   return true;
 }
 
-function requestHeaders(connection, timeoutMs) {
+function requestHeaders(connection) {
   const headers = { "content-type": contentType, "x-grpc-web": "1" };
   if (connection.token !== "") {
     headers.authorization = `Bearer ${connection.token}`;
   }
-  if (timeoutMs > 0) {
-    headers["grpc-timeout"] = `${Math.ceil(timeoutMs)}m`;
-  }
   return headers;
 }
 
-async function* invokeHTTP(connection, method, input, { signal, timeoutMs }) {
+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, timeoutMs),
+      headers: requestHeaders(connection),
       body: frame(method.input, input),
       signal,
     });
@@ -164,7 +165,7 @@ async function* invokeHTTP(connection, method, input, { signal, timeoutMs }) {
   }
 }
 
-async function* invokeWebSocket(connection, method, input, { signal, timeoutMs }) {
+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);
@@ -219,7 +220,7 @@ async function* invokeWebSocket(connection, method, input, { signal, timeoutMs }
   signal?.addEventListener("abort", abort, { once: true });
   try {
     await opened;
-    const headers = requestHeaders(connection, timeoutMs);
+    const headers = requestHeaders(connection);
     socket.send(Buffer.from(`${Object.entries(headers).map(([key, value]) => `${key}: ${value}\r\n`).join("")}`));
     const sender = (async () => {
       try {
@@ -277,30 +278,15 @@ function bind(service, connection) {
   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, timeoutMs: options.timeoutMs ?? 0 });
+      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({ host, token }) {
-  host ||= process.env.SWIPT_HOST ?? "";
-  token ||= process.env.SWIPT_TOKEN ?? "";
-  if (host === "") {
-    throw new UsageError('give --host or set SWIPT_HOST; "swipt devices" lists the hosts on the local network');
-  }
-  let parsed;
-  try {
-    parsed = new URL(host.includes("://") ? host : `http://${host}`);
-  } catch {
-    throw new UsageError(`--host is not a URL: ${host}`);
-  }
-  if (parsed.hostname === "" || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
-    throw new UsageError(`--host is an http or https URL: ${host}`);
-  }
-  const base = `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
-  const connection = { token, base, webSocketBase: base.replace(/^http/, "ws") };
+export function open({ url, token }) {
+  const connection = { token, base: url, webSocketBase: url.replace(/^http/, "ws") };
   return {
     system: bind(SystemService, connection),
     logs: bind(LogService, connection),

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);
+}

package/device.mjs

@@ -7,9 +7,9 @@ import { setTimeout as sleep } from "node:timers/promises";
 
 import { fromJson, toJson } from "@bufbuild/protobuf";
 import { ValueSchema, timestampFromMs } from "@bufbuild/protobuf/wkt";
-import Bonjour from "bonjour-service";
 
-import { UsageError, open, unauthenticated } from "./client.mjs";
+import { UsageError, unauthenticated } from "./client.mjs";
+import { attach } from "./connection.mjs";
 import { Ignorer, relativePath } from "./ignore.mjs";
 import { columns, dateTime, enumText, printLog, printScriptError, serviceText } from "./output.mjs";
 import { buildProject, loadProject } from "./project.mjs";
@@ -18,10 +18,8 @@ import { ServiceStatus, ServiceStatusSchema } from "./proto/swiplets_pb.js";
 import { sources } from "./sourcemap.mjs";
 
 const uploadChunk = 256 << 10;
-const browseLimit = 1500;
 const rebuildDelay = 300;
 const logReconnect = 2000;
-const scriptGrace = 10_000;
 
 const { version } = createRequire(import.meta.url)("./package.json");
 
@@ -41,33 +39,7 @@ function elapsed(since) {
   return `${Math.floor(seconds / 60)}m${Number((seconds % 60).toFixed(3))}s`;
 }
 
-const session = (context, run) => run(open(context.globals));
-
-export async function devices({ signal }) {
-  const bonjour = new Bonjour();
-  const found = new Map();
-  try {
-    const browser = bonjour.find({ type: "swipt" }, service => {
-      if (service.host && !found.has(service.name)) {
-        found.set(service.name, { name: service.name, host: service.host.replace(/\.$/, ""), port: service.port });
-      }
-    });
-    try {
-      await sleep(browseLimit, undefined, { signal });
-    } catch {
-      return;
-    }
-    browser.stop();
-  } finally {
-    bonjour.destroy();
-  }
-  if (found.size === 0) {
-    console.error("no device publishes Swipt on the local network; turn on Swipt › Developer › Local Network");
-    return;
-  }
-  const hostPort = service => (service.host.includes(":") ? `[${service.host}]:${service.port}` : `${service.host}:${service.port}`);
-  console.log(columns([["NAME", "HOST"], ...[...found.values()].map(service => [service.name, `http://${hostPort(service)}`])]));
-}
+const session = (context, run) => attach(context).then(run);
 
 export function printVersion() {
   console.log("swipt", version, `node ${process.versions.node}`, `${process.platform}/${process.arch}`);
@@ -436,7 +408,7 @@ export async function develop(context) {
   const project = loadProject(path.resolve(context.args[0] ?? "."));
   const root = project.root;
   sources.root = root;
-  const client = open(context.globals);
+  const client = await attach(context);
   const controller = new AbortController();
   const inner = AbortSignal.any([signal, controller.signal]);
   let fatalReject;
@@ -573,7 +545,7 @@ class ImageSink {
 }
 
 export async function js(context) {
-  const { args, options, globals } = context;
+  const { args, options, signal } = context;
   if (options.api) {
     if (args.length > 0 || options.file !== undefined || options.reset) {
       throw new UsageError("--api takes no script and no --reset");
@@ -584,7 +556,6 @@ export async function js(context) {
     return;
   }
   const { code, run } = readScript(args, options);
-  const signal = globals.timeoutMs > 0 ? AbortSignal.any([context.interrupt, AbortSignal.timeout(globals.timeoutMs + scriptGrace)]) : context.interrupt;
   await session(context, async client => {
     if (options.reset) {
       await client.repl.reset({}, { signal });
@@ -595,7 +566,7 @@ export async function js(context) {
     const script = options.file ?? "input.js";
     const images = new ImageSink(options.output);
     let failure;
-    for await (const response of client.repl.execute({ code, timeoutMs: globals.timeoutMs }, { signal })) {
+    for await (const response of client.repl.execute({ code }, { signal })) {
       switch (response.part.case) {
         case "console": {
           const output = response.part.value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swipt/cli",
-  "version": "0.1.0-nightly.33",
+  "version": "0.1.0-nightly.35",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "esbuild": "^0.28.2"
   },
   "peerDependencies": {
-    "@swipt/api": "0.1.0-nightly.33"
+    "@swipt/api": "0.1.0-nightly.35"
   },
   "devDependencies": {
     "@bufbuild/protoc-gen-es": "^2.16.0"

package/swipt.mjs

@@ -3,15 +3,14 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 
 import { Code, RpcError, UsageError } from "./client.mjs";
+import * as connection from "./connection.mjs";
 import * as device from "./device.mjs";
 import { FalseResult } from "./output.mjs";
 import { buildProject, createCommand, sourceCommand } from "./project.mjs";
 import { sources } from "./sourcemap.mjs";
 
 const globalOptions = {
-  host: { type: "string", value: "URL", help: "Swipt URL (SWIPT_HOST)" },
-  token: { type: "string", value: "TOKEN", help: "API token (SWIPT_TOKEN)" },
-  timeout: { type: "string", value: "DURATION", help: "time limit" },
+  device: { type: "string", short: "d", value: "NAME|URL", help: "the device to use (SWIPT_DEVICE)" },
   help: { type: "boolean", short: "h", help: "help" },
 };
 
@@ -73,7 +72,9 @@ const commands = [
     args: [0, Infinity],
     run: ({ args }) => sourceCommand(process.cwd(), args),
   },
-  { name: "devices", short: "List the devices that publish Swipt on the local network", args: [0, 0], run: device.devices },
+  { name: "devices", short: "List the devices, adding the ones found on the local network", args: [0, 0], run: connection.devices },
+  { name: "connect", use: "connect URL", short: "Add a device by its URL; needed when it is remote or requires a token", args: [1, 1], run: connection.connect },
+  { name: "disconnect", use: "disconnect NAME", short: "Forget a device", args: [1, 1], run: connection.disconnect },
   { name: "info", short: "Show the device and its connection", args: [0, 0], run: device.info },
   { name: "version", short: "Print the version", args: [0, 0], run: device.printVersion },
   { name: "swiplets", use: "swiplets [ID]", short: "List the swiplets or show one", args: [0, 1], options: projectOption, run: device.swiplets },
@@ -168,7 +169,7 @@ function usage(trail) {
   }
   const options = { ...trail.reduce((found, it) => ({ ...found, ...it.options }), {}), ...globalOptions };
   lines.push("", "options:");
-  lines.push(...columns(Object.entries(options).map(([option, it]) => [`  --${option}${it.value ? ` ${it.value}` : ""}`, it.help])).split("\n"));
+  lines.push(...columns(Object.entries(options).map(([option, it]) => [`  ${it.short ? `-${it.short}, ` : ""}--${option}${it.value ? ` ${it.value}` : ""}`, it.help])).split("\n"));
   return lines.join("\n");
 }
 
@@ -221,29 +222,22 @@ function resolve(argv) {
   return { trail, help, args, values: parsed.values };
 }
 
-function printError(error, { host, timeout, timedOut }, operation) {
+function printError(error, target, operation) {
   let exit = 1;
   let message = error.message;
   if (error instanceof UsageError) {
     exit = 2;
-  } else if (timedOut) {
-    message = `the command ran past --timeout ${timeout}`;
   } else if (error instanceof RpcError) {
     switch (error.code) {
       case Code.Unavailable:
         exit = 5;
-        message = `Swipt at ${host} is unreachable: ${message}`;
+        message = `Swipt at ${target.url} is unreachable: ${message}`;
         break;
       case Code.Unauthenticated:
-        message += "; copy the token from Swipt › Developer";
+        message += `; connect with the URL from Swipt › Developer: swipt connect ${connection.withToken(target.url)}`;
         break;
       case Code.Unimplemented:
-        message = `Swipt at ${host} does not have this command; update Swipt`;
-        break;
-      case Code.DeadlineExceeded:
-        if (timeout) {
-          message = `the command ran past --timeout ${timeout}`;
-        }
+        message = `Swipt at ${target.url} does not have this command; update Swipt`;
         break;
     }
   }
@@ -259,8 +253,7 @@ async function main() {
   const interrupted = () => interrupt.abort();
   process.once("SIGINT", interrupted);
   process.once("SIGTERM", interrupted);
-  let timeout;
-  const state = { host: "", timeout: undefined, timedOut: false };
+  const target = { url: "" };
   try {
     const resolved = resolve(process.argv.slice(2));
     if (resolved.help) {
@@ -269,28 +262,17 @@ async function main() {
     }
     const command = resolved.trail.at(-1);
     const values = command.parse ? command.parse(resolved.values) : resolved.values;
-    state.host = values.host ?? process.env.SWIPT_HOST ?? "";
-    state.timeout = values.timeout;
-    const timeoutMs = parseDuration(values.timeout, "--timeout");
-    if (timeoutMs > 0) {
-      timeout = AbortSignal.timeout(timeoutMs);
-      timeout.addEventListener("abort", () => {
-        state.timedOut = true;
-      });
-    }
     if (values.project !== undefined) {
       sources.root = path.resolve(values.project);
     }
-    const globals = { host: values.host ?? "", token: values.token ?? "", timeoutMs };
-    const signal = timeout ? AbortSignal.any([interrupt.signal, timeout]) : interrupt.signal;
-    await command.run({ args: resolved.args, options: values, globals, signal, interrupt: interrupt.signal, printError: (error, operation) => printError(error, state, operation) });
+    await command.run({ args: resolved.args, options: values, target, signal: interrupt.signal, printError: (error, operation) => printError(error, target, operation) });
   } catch (error) {
     if (error instanceof FalseResult) {
       process.exitCode = 1;
     } else if (interrupt.signal.aborted) {
       process.exitCode = 130;
     } else {
-      process.exitCode = printError(error, state);
+      process.exitCode = printError(error, target);
     }
   } finally {
     process.off("SIGINT", interrupted);