@visualautomate/cli 0.5.0 → 0.5.2

package/README.md

@@ -59,6 +59,10 @@ state    {"runs":1}
 A run passes when it succeeds and, if the test file names an `expectOutput`,
 leaves by that port — the same verdict as the GitHub check.
 
+The verdict is green when it passed and red when it did not, in the sandbox as
+well as out here. `NO_COLOR` turns that off, and output that is not a terminal —
+a pipe, a file, a CI log — is plain anyway; `FORCE_COLOR` turns it back on.
+
 ### In a GitHub repository
 
 `test` works wherever the platform tests your code on a push:
@@ -79,16 +83,17 @@ my-app/                       an app's repository
       …
 ```
 
-At the root of an app's repository every module runs, one after another;
-`--module send-message` runs one. `index.js` in a repository is run as written,
+At the root of an app's repository every module runs, one after another. Name one
+to run only that: `vsa test send-message`, or any short name that picks it out —
+`vsa test send`. `--module <name>` is the same thing. `index.js` in a repository is run as written,
 unbundled, because that is the file the sandbox loads.
 
 ## `dev`
 
 ```bash
-vsa dev
-vsa dev --module send-message
-vsa dev --tier boosted
+vsa dev                    # every module in modules/
+vsa dev send-message       # one of them; the shortest name that picks it will do
+vsa dev --tier boosted     # a bigger machine
 vsa dev --local            # on this machine's Node, without the sandbox
 ```
 

package/dist/index.js

@@ -1822,6 +1822,14 @@ var ENTRIES = ["plugin.ts", "plugin.js", "index.ts", "index.js"];
 function entryIn(dir) {
   return ENTRIES.map((file2) => join(dir, file2)).find((file2) => existsSync(file2)) ?? null;
 }
+function matchFolders(folders, name) {
+  const wanted2 = name.trim().toLowerCase();
+  const exact = folders.filter((folder) => folder.toLowerCase() === wanted2);
+  if (exact.length > 0) return exact;
+  const prefix = folders.filter((folder) => folder.toLowerCase().startsWith(wanted2));
+  if (prefix.length > 0) return prefix;
+  return folders.filter((folder) => folder.toLowerCase().includes(wanted2));
+}
 function findTargets(cwd, only) {
   const dir = resolve(cwd);
   const modulesDir = join(dir, "modules");
@@ -1830,16 +1838,16 @@ function findTargets(cwd, only) {
     if (folders.length === 0) {
       throw new Error("There is a modules/ folder here, but none of its folders has a manifest.json.");
     }
-    const chosen = only ? folders.filter((f) => f === only) : folders;
+    const chosen = only ? matchFolders(folders, only) : folders;
     if (only && chosen.length === 0) {
-      throw new Error(`No module "${only}" in modules/. There is: ${folders.join(", ")}.`);
+      throw new Error(`No module matches "${only}". This repository has: ${folders.join(", ")}.`);
     }
     return chosen.map((folder) => targetIn(join(modulesDir, folder), `modules/${folder}`)).filter(Boolean);
   }
   const target = targetIn(dir, basename(dir));
   if (!target) {
     throw new Error(
-      "Nothing to test here: no plugin.ts, plugin.js or index.js, and no modules/ folder.\nRun this in a plugin's folder, at the root of its repository, or run `visualautomate init <name>`."
+      "Nothing to test here: no plugin.ts, plugin.js or index.js, and no modules/ folder.\nRun this in a module's folder, at the root of its repository, or run `vsa init <name>`."
     );
   }
   return [target];
@@ -2079,6 +2087,38 @@ async function savePersisted(dir, files, state) {
 
 // src/docker.ts
 import { spawnSync } from "node:child_process";
+
+// src/colour.ts
+var CODES = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m"
+};
+function wanted() {
+  const env = process.env;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+  return Boolean(process.stdout.isTTY);
+}
+var ON = wanted();
+function paint(code) {
+  return (text) => ON ? `${code}${text}${CODES.reset}` : text;
+}
+var red = paint(CODES.red);
+var green = paint(CODES.green);
+var yellow = paint(CODES.yellow);
+var blue = paint(CODES.blue);
+var dim = paint(CODES.dim);
+var bold = paint(CODES.bold);
+function colourEnv() {
+  return ON ? ["--env", "FORCE_COLOR=1"] : ["--env", "NO_COLOR=1"];
+}
+
+// src/docker.ts
 var IMAGE = "ghcr.io/visualautomate/plugin-sandbox";
 var TIERS = {
   standard: { cpus: "0.25", memory: "1g" },
@@ -2111,6 +2151,9 @@ function dockerArgs(run) {
     "ALL",
     "--security-opt",
     "no-new-privileges",
+    // So a run inside the container is as readable as one out here: its
+    // stdout is a pipe to Docker, which would otherwise turn colour off.
+    ...colourEnv(),
     ...run.user ? ["--user", `${run.user.uid}:${run.user.gid}`] : [],
     run.image,
     ...run.args
@@ -2134,16 +2177,18 @@ function dockerProblem() {
 function explainExit(code, tier) {
   if (code === 137) {
     const next = Object.keys(TIERS)[Object.keys(TIERS).indexOf(tier) + 1];
-    return `\u2717 stopped   the step used more than the ${TIERS[tier].memory.replace("g", " GB")} of memory the ${tier} tier has, and the container was killed. On the platform it would stop the same way.` + (next ? ` To check it fits a bigger machine: --tier ${next}` : "");
+    return red(
+      `\u2717 stopped   the step used more than the ${TIERS[tier].memory.replace("g", " GB")} of memory the ${tier} tier has, and the container was killed. On the platform it would stop the same way.` + (next ? ` To check it fits a bigger machine: --tier ${next}` : "")
+    );
   }
-  if (code === 125) return "\u2717 Docker could not start the container. Is the image available? Try: docker pull " + IMAGE;
+  if (code === 125) return red("\u2717 Docker could not start the container. Is the image available? Try: docker pull " + IMAGE);
   return null;
 }
 function ensureDocker(say, waitMs = 12e4) {
   const problem = dockerProblem();
   if (!problem) return null;
   if (problem.includes("not installed")) return problem;
-  say("Docker is not running. Starting Docker Desktop\u2026");
+  say(yellow("Docker is not running. Starting Docker Desktop\u2026"));
   const started = spawnSync("docker", ["desktop", "start"], { encoding: "utf8" });
   if (started.status !== 0) {
     say("Could not start it from here \u2014 start Docker Desktop yourself; this will carry on when it is up.");
@@ -2177,7 +2222,7 @@ function runInDocker(run) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.5.0" : "0.0.0-dev";
+var VERSION = true ? "0.5.2" : "0.0.0-dev";
 var DEFAULT_API_URL = "https://visualautomate.com";
 function configPath() {
   return join3(homedir(), ".visualautomate", "config.json");
@@ -2204,7 +2249,7 @@ async function tokenFor(flags) {
   return { token, apiUrl };
 }
 function fail(message) {
-  console.error(message);
+  console.error(red(message));
   throw new SilentExit();
 }
 var SilentExit = class extends Error {
@@ -2281,8 +2326,8 @@ async function cmdLogin(flags) {
   });
   const who = await whoami(apiUrl, token);
   await writeConfig({ token, apiUrl, email: who.email });
-  ok(`
-\u2713 Signed in as ${who.email}`);
+  ok(green(`
+\u2713 Signed in as ${who.email}`));
   ok(`  Token stored in ${configPath()}`);
 }
 async function whoami(apiUrl, token) {
@@ -2368,9 +2413,9 @@ visualautomate push     # publish it to your account
 \`test.json\` is the input, config and state \`test\` runs with.
 `
   );
-  ok(`
+  ok(green(`
 \u2713 Created ${name} from the "${templateName}" template
-`);
+`));
   ok("  cd " + name);
   ok("  visualautomate test");
   ok("  visualautomate push\n");
@@ -2404,12 +2449,12 @@ function line(indent, text) {
 async function runTarget(target, flags, several) {
   const say = (text) => line(several, text);
   if (several) ok(`
-\u25B8 ${target.name}`);
+${bold(`\u25B8 ${target.name}`)}`);
   try {
     const code = await codeFor(target);
     const check = validatePluginCode(code);
     if (!check.valid) {
-      say(`\u2717 refused   ${check.error}`);
+      say(`${red("\u2717 refused")}   ${check.error}`);
       return false;
     }
     const settings = await readTestFile(target.dir, flags.input);
@@ -2423,7 +2468,7 @@ async function runTarget(target, flags, several) {
         const manifest = parseJsonc(await readFile3(manifestPath, "utf8")).value;
         outputs = manifest.outputs ?? [];
       } catch (error) {
-        say(`\u2717 manifest.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        say(red(`\u2717 manifest.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`));
         return false;
       }
     }
@@ -2449,33 +2494,37 @@ async function runTarget(target, flags, several) {
     const port = result.output?.output ?? null;
     const expected = settings.expectOutput;
     const passed = result.status === "success" && (!expected || port === expected);
-    say(`${passed ? "\u2713 passed" : "\u2717 failed"}  ${result.status}, ${result.durationMs}ms`);
-    if (result.error) say(`error    ${result.error}`);
+    const verdict = passed ? green(bold("\u2713 passed")) : red(bold("\u2717 failed"));
+    say(`${verdict}  ${dim(`${result.status}, ${result.durationMs}ms`)}`);
+    if (result.error) say(`${dim("error")}    ${red(result.error)}`);
     if (result.output) {
-      say(`output   ${port}${expected ? ` (expected ${expected})` : ""}`);
-      say(`data     ${JSON.stringify(result.output.data, null, 2).replace(/\n/g, "\n         ")}`);
+      const port_ = passed || !expected ? port : red(String(port));
+      say(`${dim("output")}   ${port_}${expected ? dim(` (expected ${expected})`) : ""}`);
+      say(`${dim("data")}     ${JSON.stringify(result.output.data, null, 2).replace(/\n/g, "\n         ")}`);
     }
-    if (result.files.size > 0) say(`files    ${[...result.files.keys()].join(", ")}`);
-    if (result.state.size > 0) say(`state    ${JSON.stringify(Object.fromEntries(result.state))}`);
-    for (const entry of result.logs ?? []) say(`log      ${entry}`);
+    if (result.files.size > 0) say(`${dim("files")}    ${[...result.files.keys()].join(", ")}`);
+    if (result.state.size > 0) say(`${dim("state")}    ${JSON.stringify(Object.fromEntries(result.state))}`);
+    for (const entry of result.logs ?? []) say(`${dim("log")}      ${entry}`);
     for (const [host, enforced] of denied) {
       say(
-        enforced ? `egress   blocked ${host} \u2014 not in allowedDomains` : `! egress ${host} is not allowed on the platform unless the plugin declares it. Add "allowedDomains": ["${host}"] to the test file to check with the same rule.`
+        enforced ? `${dim("egress")}   ${red(`blocked ${host}`)} \u2014 not in allowedDomains` : yellow(`! egress ${host} is not allowed on the platform unless the plugin declares it. `) + `Add "allowedDomains": ["${host}"] to the test file to check with the same rule.`
       );
     }
     if (persist) {
       const refused = await savePersisted(target.dir, result.files, result.state);
-      say(`kept     storage and state in ${relative3(process.cwd(), join3(target.dir, ".visualautomate")) || ".visualautomate"}`);
-      for (const path of refused) say(`! storage path "${path}" points outside the storage folder and was not written`);
+      say(`${dim("kept")}     ${dim(`storage and state in ${relative3(process.cwd(), join3(target.dir, ".visualautomate")) || ".visualautomate"}`)}`);
+      for (const path of refused) say(yellow(`! storage path "${path}" points outside the storage folder and was not written`));
     }
     if (port && outputs.length > 0 && !outputs.includes(port)) {
       say(
-        `! This returned output "${port}", which manifest.json does not list (it has ${outputs.map((o) => `"${o}"`).join(", ")}). On a canvas nothing would follow it.`
+        yellow(
+          `! This returned output "${port}", which manifest.json does not list (it has ${outputs.map((o) => `"${o}"`).join(", ")}). On a canvas nothing would follow it.`
+        )
       );
     }
     return passed;
   } catch (error) {
-    say(`\u2717 ${error instanceof Error ? error.message : String(error)}`);
+    say(red(`\u2717 ${error instanceof Error ? error.message : String(error)}`));
     return false;
   }
 }
@@ -2484,8 +2533,11 @@ async function runTargets(targets, flags) {
   for (const target of targets) {
     if (await runTarget(target, flags, targets.length > 1)) passed++;
   }
-  if (targets.length > 1) ok(`
-${passed} of ${targets.length} passed`);
+  if (targets.length > 1) {
+    const tally = `${passed} of ${targets.length} passed`;
+    ok(`
+${passed === targets.length ? green(bold(tally)) : red(bold(tally))}`);
+  }
   return passed === targets.length;
 }
 function packageLoader(dir) {
@@ -2538,31 +2590,41 @@ function runTargetsInDocker(targets, all, flags) {
   }
   return passed;
 }
-function targetsOrFail(flags) {
+function targetsOrFail(args, flags) {
   try {
-    return findTargets(process.cwd(), flags.module);
+    return findTargets(process.cwd(), args[0] ?? flags.module);
   } catch (error) {
     fail(error instanceof Error ? error.message : String(error));
   }
 }
-async function cmdTest(flags) {
-  const targets = targetsOrFail(flags);
+function sayWhatRuns(targets, picked) {
+  if (targets.length === 1) {
+    ok(`Running ${targets[0].name}`);
+    return;
+  }
+  ok(`Running ${targets.length} modules: ${targets.map((t) => t.name.replace(/^modules\//, "")).join(", ")}`);
+  if (!picked) ok(dim(`One of them: vsa dev ${targets[0].name.replace(/^modules\//, "")}`));
+}
+async function cmdTest(args, flags) {
+  const targets = targetsOrFail(args, flags);
   if (flags.docker) prepareSandbox(flags);
   const passed = flags.docker ? runTargetsInDocker(targets, targets, flags) : await runTargets(targets, flags);
   if (!passed) process.exitCode = 1;
 }
-async function cmdDev(flags) {
+async function cmdDev(args, flags) {
   const root = process.cwd();
-  let targets = targetsOrFail(flags);
+  const picked = args[0] ?? flags.module;
+  let targets = targetsOrFail(args, flags);
   const inSandbox = flags.local !== "true";
   if (inSandbox) prepareSandbox(flags);
   const header = () => {
     process.stdout.write("\x1Bc");
-    ok(`vsa dev \u2014 ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \u2014 Ctrl+C to stop`);
+    ok(`${bold("vsa dev")} ${dim(`\u2014 ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \u2014 Ctrl+C to stop`)}`);
   };
   const run = async (chosen) => inSandbox ? runTargetsInDocker(chosen, targets, flags) : runTargets(chosen, flags);
   header();
-  ok(inSandbox ? `in ${imageFor(flags)}, tier ${flags.tier || "standard"}` : "on this machine, not in the sandbox");
+  ok(dim(inSandbox ? `in ${imageFor(flags)}, tier ${flags.tier || "standard"}` : "on this machine, not in the sandbox"));
+  sayWhatRuns(targets, Boolean(picked));
   await run(targets);
   const ignored = [`${sep2}node_modules${sep2}`, `${sep2}.git${sep2}`, `${sep2}dist${sep2}`, `${sep2}.visualautomate${sep2}`];
   const pending = /* @__PURE__ */ new Set();
@@ -2577,17 +2639,17 @@ async function cmdDev(flags) {
     const changed = [...pending];
     pending.clear();
     try {
-      targets = findTargets(root, flags.module);
+      targets = findTargets(root, picked);
     } catch (error) {
       header();
-      ok(`\u2717 ${error instanceof Error ? error.message : String(error)}`);
+      ok(red(`\u2717 ${error instanceof Error ? error.message : String(error)}`));
       running = false;
       return;
     }
     const hit = changed.map((path) => targetForPath(targets, path));
     const chosen = hit.some((t) => t === null) ? targets : [...new Set(hit)];
     header();
-    ok(`changed: ${changed.map((p) => relative3(root, p)).join(", ")}`);
+    ok(dim(`changed: ${changed.map((p) => relative3(root, p)).join(", ")}`));
     await run(chosen);
     running = false;
   };
@@ -2689,8 +2751,8 @@ ${text.slice(0, 500)}`);
   if (!res.ok || !data.success) {
     fail(`Push refused: ${data.error ?? `status ${res.status}`}`);
   }
-  ok(`
-\u2713 Published (id: ${data.pluginId})`);
+  ok(green(`
+\u2713 Published (id: ${data.pluginId})`));
   ok(`  A version snapshot was saved, so you can roll back from the dashboard.`);
 }
 function printHelp() {
@@ -2699,8 +2761,8 @@ vsa \u2014 build and publish VisualAutomate plugins
 
   vsa login                    sign this machine in
   vsa init <name> [--template] start a plugin
-  vsa dev [--module <name>]    the sandbox, and a run again on every save
-  vsa test [--module <name>]   run it once, as the platform's check does
+  vsa dev [<module>]           the sandbox, and a run again on every save
+  vsa test [<module>]          run it once, as the platform's check does
   vsa push                     publish it
   vsa whoami                   which account this is
   vsa logout                   forget the token
@@ -2712,11 +2774,11 @@ Templates: ${Object.keys(TEMPLATES).join(", ")}
 
 \`test\` and \`dev\` work in a plugin made with \`init\`, at the root of a plugin's
 GitHub repository, and at the root of an app's repository, where every folder
-in modules/ is run (or the one named with --module). The run's settings come
+in modules/ is run (or the one you name: vsa dev send-message). The run's settings come
 from visualautomate.test.json, test.json, or --input <file>.
 
 Options for \`dev\` and \`test\`:
-  --module <name>      one folder of modules/ instead of all of them
+  --module <name>      the same as naming it: vsa dev send-message
   --tier <name>        the sandbox's size: standard, boosted, high or max
   --image <ref>        a different sandbox image
   --persist            keep storage and state in .visualautomate/ between runs
@@ -2761,17 +2823,17 @@ async function main() {
     case "new":
       return cmdInit(args, flags);
     case "test":
-      return cmdTest(flags);
+      return cmdTest(args, flags);
     case "dev":
     case "watch":
-      return cmdDev(flags);
+      return cmdDev(args, flags);
     case "push":
     case "publish":
       return cmdPush(flags);
     // `plugin test` and `plugin push` are accepted as aliases.
     case "plugin": {
       const sub = args.shift();
-      if (sub === "test") return cmdTest(flags);
+      if (sub === "test") return cmdTest(args, flags);
       if (sub === "push") return cmdPush(flags);
       printHelp();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visualautomate/cli",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Build and publish VisualAutomate plugins.",
   "license": "MIT",
   "type": "module",