@swipt/cli 0.1.0-nightly.42 → 0.1.0-nightly.44

package/swipt.mjs

@@ -12,9 +12,24 @@ const globalOptions = {
   help: { type: "boolean", short: "h", help: "help" },
 };
 
-const deviceOption = { device: { type: "string", short: "d", value: "NAME|URL", help: "the device to use (SWIPT_DEVICE)" } };
+const deviceOption = {
+  device: {
+    type: "string",
+    short: "d",
+    value: "NAME|URL",
+    help: "the device to use (SWIPT_DEVICE)",
+  },
+};
 
-const durationUnits = { ns: 1e-6, us: 1e-3, "µs": 1e-3, ms: 1, s: 1000, m: 60_000, h: 3_600_000 };
+const durationUnits = {
+  ns: 1e-6,
+  us: 1e-3,
+  µs: 1e-3,
+  ms: 1,
+  s: 1000,
+  m: 60_000,
+  h: 3_600_000,
+};
 
 function parseDuration(text, option) {
   if (text === undefined) {
@@ -28,7 +43,9 @@ function parseDuration(text, option) {
   while (rest !== "") {
     const match = /^(\d+(?:\.\d*)?|\.\d+)(ns|us|µs|ms|s|m|h)/.exec(rest);
     if (!match) {
-      throw new UsageError(`invalid argument ${JSON.stringify(text)} for ${option}: it is a duration such as 30s or 1m30s`);
+      throw new UsageError(
+        `invalid argument ${JSON.stringify(text)} for ${option}: it is a duration such as 30s or 1m30s`,
+      );
     }
     total += Number(match[1]) * durationUnits[match[2]];
     rest = rest.slice(match[0].length);
@@ -41,7 +58,9 @@ function parseCount(text, option) {
     return undefined;
   }
   if (!/^\d+$/.test(text) || Number(text) > 0xffffffff) {
-    throw new UsageError(`invalid argument ${JSON.stringify(text)} for ${option}: it is a number`);
+    throw new UsageError(
+      `invalid argument ${JSON.stringify(text)} for ${option}: it is a number`,
+    );
   }
   return Number(text);
 }
@@ -52,11 +71,50 @@ const dataCommands = (operand, files) => {
     name: "data",
     short: `Manage the files in the data directory of ${operand === "" ? "the REPL" : "a swiplet"}`,
     commands: [
-      { name: "list", use: `list ${operand}[PATH]`, short: "List data files", args: [before, before + 1], options: { recursive: { type: "boolean", help: "include subdirectories" } }, run: files.list },
-      { name: "read", use: `read ${operand}PATH`, short: "Read a data file or directory", args: [before + 1, before + 1], options: { output: { type: "string", value: "PATH", help: "destination" } }, run: files.read },
-      { name: "write", use: `write ${operand}PATH [FILE | -]`, short: "Write a data file", args: [before + 1, before + 2], run: files.write },
-      { name: "remove", use: `remove ${operand}PATH`, short: "Remove a data file", args: [before + 1, before + 1], options: { recursive: { type: "boolean", help: "include directory contents" } }, run: files.remove },
-      { name: "clear", use: `clear ${operand}`.trimEnd(), short: "Remove every data file, keeping the data directory", args: [before, before], run: files.clear },
+      {
+        name: "list",
+        use: `list ${operand}[PATH]`,
+        short: "List data files",
+        args: [before, before + 1],
+        options: {
+          recursive: { type: "boolean", help: "include subdirectories" },
+        },
+        run: files.list,
+      },
+      {
+        name: "read",
+        use: `read ${operand}PATH`,
+        short: "Read a data file or directory",
+        args: [before + 1, before + 1],
+        options: {
+          output: { type: "string", value: "PATH", help: "destination" },
+        },
+        run: files.read,
+      },
+      {
+        name: "write",
+        use: `write ${operand}PATH [FILE | -]`,
+        short: "Write a data file",
+        args: [before + 1, before + 2],
+        run: files.write,
+      },
+      {
+        name: "remove",
+        use: `remove ${operand}PATH`,
+        short: "Remove a data file",
+        args: [before + 1, before + 1],
+        options: {
+          recursive: { type: "boolean", help: "include directory contents" },
+        },
+        run: files.remove,
+      },
+      {
+        name: "clear",
+        use: `clear ${operand}`.trimEnd(),
+        short: "Remove every data file, keeping the data directory",
+        args: [before, before],
+        run: files.clear,
+      },
     ],
   };
 };
@@ -86,17 +144,28 @@ const commands = [
       {
         name: "source",
         use: "source [SWIPLET...]",
-        short: 'Gather the built swiplets of this directory\'s workspaces, or the given ones, into dist/ with a swiplets.json described by "source" in package.json',
+        short:
+          'Gather the built swiplets of this directory\'s workspaces, or the given ones, into dist/ with a swiplets.json described by "source" in package.json',
         args: [0, Infinity],
         run: ({ args }) => sourceCommand(process.cwd(), args),
       },
-      { name: "deploy", use: "deploy [PROJECT]", short: "Build the project and install it on the device", args: [0, 1], options: deviceOption, run: device.deployProject },
+      {
+        name: "deploy",
+        use: "deploy [PROJECT]",
+        short: "Build the project and install it on the device",
+        args: [0, 1],
+        options: deviceOption,
+        run: device.deployProject,
+      },
       {
         name: "develop",
         use: "develop [PROJECT]",
         short: "Build, install and follow a swiplet project as it changes",
         args: [0, 1],
-        options: { ...deviceOption, "no-logs": { type: "boolean", help: "without logs" } },
+        options: {
+          ...deviceOption,
+          "no-logs": { type: "boolean", help: "without logs" },
+        },
         run: device.develop,
       },
     ],
@@ -105,9 +174,27 @@ const commands = [
     name: "device",
     short: "Manage the devices and read their logs",
     commands: [
-      { name: "list", short: "List the devices, adding the ones found on the local network", args: [0, 0], run: connection.list },
-      { name: "add", use: "add URL", short: "Add a device by its URL; needed when it is remote or requires a token", args: [1, 1], run: connection.add },
-      { name: "remove", use: "remove NAME", short: "Forget a device", args: [1, 1], run: connection.remove },
+      {
+        name: "list",
+        short: "List the devices, adding the ones found on the local network",
+        args: [0, 0],
+        run: connection.list,
+      },
+      {
+        name: "add",
+        use: "add URL",
+        short:
+          "Add a device by its URL; needed when it is remote or requires a token",
+        args: [1, 1],
+        run: connection.add,
+      },
+      {
+        name: "remove",
+        use: "remove NAME",
+        short: "Forget a device",
+        args: [1, 1],
+        run: connection.remove,
+      },
       {
         name: "logs",
         short: "Print the logs",
@@ -115,12 +202,25 @@ const commands = [
         options: {
           ...deviceOption,
           follow: { type: "boolean", help: "follow new entries" },
-          tail: { type: "string", value: "COUNT", help: "number of past entries (default 100)" },
+          tail: {
+            type: "string",
+            value: "COUNT",
+            help: "number of past entries (default 100)",
+          },
           since: { type: "string", value: "DURATION", help: "maximum age" },
-          level: { type: "string", value: "LEVEL", help: "minimum level (default info)" },
+          level: {
+            type: "string",
+            value: "LEVEL",
+            help: "minimum level (default info)",
+          },
           swiplet: { type: "string", value: "ID", help: "swiplet ID" },
         },
-        parse: options => ({ ...options, tail: parseCount(options.tail, "--tail"), since: parseDuration(options.since, "--since"), level: options.level ?? "info" }),
+        parse: (options) => ({
+          ...options,
+          tail: parseCount(options.tail, "--tail"),
+          since: parseDuration(options.since, "--since"),
+          level: options.level ?? "info",
+        }),
         run: device.logs,
       },
     ],
@@ -130,25 +230,74 @@ const commands = [
     short: "Manage the swiplets on the device",
     options: deviceOption,
     commands: [
-      { name: "list", short: "List the swiplets", args: [0, 0], run: device.list },
-      { name: "show", use: "show ID", short: "Show a swiplet", args: [1, 1], run: device.show },
-      { name: "install", use: "install ARCHIVE", short: "Install a swiplet archive", args: [1, 1], run: device.install },
-      { name: "remove", use: "remove ID", short: "Remove a swiplet", args: [1, 1], run: device.remove },
+      {
+        name: "list",
+        short: "List the swiplets",
+        args: [0, 0],
+        run: device.list,
+      },
+      {
+        name: "show",
+        use: "show ID",
+        short: "Show a swiplet",
+        args: [1, 1],
+        run: device.show,
+      },
+      {
+        name: "install",
+        use: "install ARCHIVE",
+        short: "Install a swiplet archive",
+        args: [1, 1],
+        run: device.install,
+      },
+      {
+        name: "remove",
+        use: "remove ID",
+        short: "Remove a swiplet",
+        args: [1, 1],
+        run: device.remove,
+      },
       {
         name: "call",
         use: "call ID ACTION",
         short: "Call a swiplet action",
         args: [2, 2],
-        options: { input: { type: "string", value: "JSON", help: "input JSON, @FILE or -" } },
+        options: {
+          input: {
+            type: "string",
+            value: "JSON",
+            help: "input JSON, @FILE or -",
+          },
+        },
         run: device.call,
       },
       {
         name: "service",
         short: "Manage swiplet services",
         commands: [
-          { name: "enable", use: "enable ID", short: "Turn on a swiplet service", args: [1, 1], options: { watch: { type: "boolean", help: "watch the state" } }, run: device.setService(true) },
-          { name: "disable", use: "disable ID", short: "Turn off a swiplet service", args: [1, 1], options: { watch: { type: "boolean", help: "watch the state" } }, run: device.setService(false) },
-          { name: "watch", use: "watch [ID]", short: "Watch swiplet services", args: [0, 1], run: device.serviceWatch },
+          {
+            name: "enable",
+            use: "enable ID",
+            short: "Turn on a swiplet service",
+            args: [1, 1],
+            options: { watch: { type: "boolean", help: "watch the state" } },
+            run: device.setService(true),
+          },
+          {
+            name: "disable",
+            use: "disable ID",
+            short: "Turn off a swiplet service",
+            args: [1, 1],
+            options: { watch: { type: "boolean", help: "watch the state" } },
+            run: device.setService(false),
+          },
+          {
+            name: "watch",
+            use: "watch [ID]",
+            short: "Watch swiplet services",
+            args: [0, 1],
+            run: device.serviceWatch,
+          },
         ],
       },
       dataCommands("ID ", device.swipletData),
@@ -169,25 +318,56 @@ const commands = [
           "FILE, or standard input given as - or no argument, is a program; only its console output and thrown error are printed, and the global args holds its ARGs.",
           'Top-level await is available, and top-level bindings persist across runs until "swipt repl reset".',
           "An image given to show(), or as the completion value of CODE, is saved as a PNG file and printed as its path.",
-          'There is no module system, so import is unavailable; the globals are accessibility, input, device, screen, image, dialog, dataDirectory, show and sleep, declared by "swipt repl api".',
-          'dataDirectory is the directory that "swipt repl data" manages.',
+          'The globals are accessibility, input, device, screen, image, dialog, dataDirectory, show and sleep; import declarations and import() load the modules that swiplets get from Swipt; "swipt repl api" declares both.',
+          'dataDirectory, which also holds the expo-sqlite databases, is the directory that "swipt repl data" manages.',
         ],
         args: [0, Infinity],
         passthrough: device.isProgram,
-        options: { output: { type: "string", value: "DIRECTORY", help: "image directory (default: a new temporary directory)" } },
+        options: {
+          output: {
+            type: "string",
+            value: "DIRECTORY",
+            help: "image directory (default: a new temporary directory)",
+          },
+        },
         run: device.run,
       },
-      { name: "reset", short: "Reset the session", args: [0, 0], run: device.reset },
-      { name: "api", short: "Print the TypeScript declarations of the globals", args: [0, 0], run: device.api },
+      {
+        name: "reset",
+        short: "Reset the session",
+        args: [0, 0],
+        run: device.reset,
+      },
+      {
+        name: "api",
+        short: "Print the TypeScript declarations of the globals and modules",
+        args: [0, 0],
+        run: device.api,
+      },
       dataCommands("", device.replData),
     ],
   },
-  { name: "version", short: "Print the version", args: [0, 0], run: device.printVersion },
+  {
+    name: "version",
+    short: "Print the version",
+    args: [0, 0],
+    run: device.printVersion,
+  },
 ];
 
-const root = { name: "swipt", short: "Operate a device through Swipt", commands };
+const root = {
+  name: "swipt",
+  short: "Operate a device through Swipt",
+  commands,
+};
 
-const parseOptions = options => Object.fromEntries(Object.entries(options ?? {}).map(([name, option]) => [name, { type: option.type, ...(option.short ? { short: option.short } : {}) }]));
+const parseOptions = (options) =>
+  Object.fromEntries(
+    Object.entries(options ?? {}).map(([name, option]) => [
+      name,
+      { type: option.type, ...(option.short ? { short: option.short } : {}) },
+    ]),
+  );
 
 function allOptions(command, collected = {}) {
   Object.assign(collected, parseOptions(command.options));
@@ -199,31 +379,61 @@ function allOptions(command, collected = {}) {
 
 function usage(trail) {
   const command = trail.at(-1);
-  const name = trail.map(it => it.name).join(" ");
+  const name = trail.map((it) => it.name).join(" ");
   const lines = [command.short, ""];
   if (command.commands) {
     lines.push(`usage: ${name} COMMAND`, "", "commands:");
-    lines.push(...columns(command.commands.map(child => [`  ${child.use ?? child.name}`, child.short])).split("\n"));
+    lines.push(
+      ...columns(
+        command.commands.map((child) => [
+          `  ${child.use ?? child.name}`,
+          child.short,
+        ]),
+      ).split("\n"),
+    );
   } else {
-    lines.push(`usage: ${trail.slice(0, -1).map(it => it.name).join(" ")} ${command.use ?? command.name}`.replace(/ +/g, " "));
+    lines.push(
+      `usage: ${trail
+        .slice(0, -1)
+        .map((it) => it.name)
+        .join(" ")} ${command.use ?? command.name}`.replace(/ +/g, " "),
+    );
   }
   if (command.description) {
     lines.push("", ...command.description);
   }
-  const options = { ...trail.reduce((found, it) => ({ ...found, ...it.options }), {}), ...globalOptions };
+  const options = {
+    ...trail.reduce((found, it) => ({ ...found, ...it.options }), {}),
+    ...globalOptions,
+  };
   lines.push("", "options:");
-  lines.push(...columns(Object.entries(options).map(([option, it]) => [`  ${it.short ? `-${it.short}, ` : ""}--${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");
 }
 
 function columns(rows) {
-  const width = Math.max(...rows.map(row => row[0].length));
-  return rows.map(row => `${row[0].padEnd(width + 2)}${row[1]}`).join("\n");
+  const width = Math.max(...rows.map((row) => row[0].length));
+  return rows.map((row) => `${row[0].padEnd(width + 2)}${row[1]}`).join("\n");
 }
 
 function resolve(argv) {
-  const loose = parseArgs({ args: argv, options: { ...parseOptions(globalOptions), ...allOptions(root) }, allowPositionals: true, strict: false, tokens: true });
-  const positionals = loose.tokens.filter(token => token.kind === "positional");
+  const loose = parseArgs({
+    args: argv,
+    options: { ...parseOptions(globalOptions), ...allOptions(root) },
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+  });
+  const positionals = loose.tokens.filter(
+    (token) => token.kind === "positional",
+  );
   const trail = [root];
   let consumed = 0;
   let help = positionals[0]?.value === "help";
@@ -239,31 +449,56 @@ function resolve(argv) {
       }
       throw new UsageError("a command is missing");
     }
-    const found = current.commands.find(it => it.name === word);
+    const found = current.commands.find((it) => it.name === word);
     if (!found) {
-      throw new UsageError(`unknown command ${JSON.stringify(word)} for ${JSON.stringify(trail.map(it => it.name).join(" "))}`);
+      throw new UsageError(
+        `unknown command ${JSON.stringify(word)} for ${JSON.stringify(trail.map((it) => it.name).join(" "))}`,
+      );
     }
     trail.push(found);
     consumed++;
   }
   const command = trail.at(-1);
-  const options = trail.reduce((found, it) => ({ ...found, ...it.options }), {});
+  const options = trail.reduce(
+    (found, it) => ({ ...found, ...it.options }),
+    {},
+  );
   const first = positionals[consumed];
-  const verbatim = first !== undefined && command.passthrough?.(first.value) ? first.index + 1 : argv.length;
+  const verbatim =
+    first !== undefined && command.passthrough?.(first.value)
+      ? first.index + 1
+      : argv.length;
   let parsed;
   try {
-    parsed = parseArgs({ args: argv.slice(0, verbatim), options: { ...parseOptions(globalOptions), ...parseOptions(options) }, allowPositionals: true, strict: true });
+    parsed = parseArgs({
+      args: argv.slice(0, verbatim),
+      options: { ...parseOptions(globalOptions), ...parseOptions(options) },
+      allowPositionals: true,
+      strict: true,
+    });
   } catch (error) {
     const option = error.message.match(/^Unknown option '(-[^']*)'/)?.[1];
-    throw new UsageError(option === undefined ? error.message : `${option} is not an option of ${JSON.stringify(trail.map(it => it.name).join(" "))}`);
+    throw new UsageError(
+      option === undefined
+        ? error.message
+        : `${option} is not an option of ${JSON.stringify(trail.map((it) => it.name).join(" "))}`,
+    );
   }
   if (parsed.values.help) {
     help = true;
   }
   const args = [...parsed.positionals.slice(consumed), ...argv.slice(verbatim)];
-  if (!help && (args.length < command.args[0] || args.length > command.args[1])) {
+  if (
+    !help &&
+    (args.length < command.args[0] || args.length > command.args[1])
+  ) {
     const [least, most] = command.args;
-    const expected = least === most ? `${least} arg(s)` : most === Infinity ? `at least ${least} arg(s)` : `between ${least} and ${most} arg(s)`;
+    const expected =
+      least === most
+        ? `${least} arg(s)`
+        : most === Infinity
+          ? `at least ${least} arg(s)`
+          : `between ${least} and ${most} arg(s)`;
     throw new UsageError(`accepts ${expected}, received ${args.length}`);
   }
   return { trail, help, args, values: parsed.values };
@@ -288,7 +523,10 @@ function printError(error, target, operation) {
         break;
     }
   }
-  console.error("error:", operation === undefined ? message : `${operation}: ${message}`);
+  console.error(
+    "error:",
+    operation === undefined ? message : `${operation}: ${message}`,
+  );
   if (exit === 2) {
     console.error('run "swipt help" for usage');
   }
@@ -308,8 +546,16 @@ async function main() {
       return;
     }
     const command = resolved.trail.at(-1);
-    const values = command.parse ? command.parse(resolved.values) : resolved.values;
-    await command.run({ args: resolved.args, options: values, target, signal: interrupt.signal, printError: (error, operation) => printError(error, target, operation) });
+    const values = command.parse
+      ? command.parse(resolved.values)
+      : resolved.values;
+    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;