@tailglow/cli 0.9.6 → 0.9.15

package/src/import-file.js

@@ -11,6 +11,7 @@ function checkAbort(signal) {
 /** @param {string} [message] */
 function changedInput(message = "The input file changed while it was being read.") {
   const error = new Error(message);
+
   return Object.assign(error, { code: "IMPORT_SOURCE_CHANGED" });
 }
 
@@ -23,25 +24,37 @@ function changedInput(message = "The input file changed while it was being read.
  */
 export async function openImportFile(file_path, { signal } = {}) {
   checkAbort(signal);
+
   const handle = await open(file_path, constants.O_RDONLY | constants.O_NONBLOCK);
+
   try {
     const initial = await handle.stat({ bigint: true });
+
     if (!initial.isFile()) throw new Error("Import input must be a regular file.");
+
     const size = Number(initial.size);
+
     if (!Number.isSafeInteger(size))
       throw new Error("The input file is too large to address safely.");
+
     let is_closed = false;
+
     async function assertUnchanged() {
       checkAbort(signal);
+
       if (is_closed) throw new Error("The import file reader is closed.");
+
       const current = await stat(file_path, { bigint: true }).catch(() => null);
       const opened = await handle.stat({ bigint: true });
+
       if (!current || !sameFile(initial, current) || !sameFile(initial, opened))
         throw changedInput();
     }
+
     /** @param {number} start @param {number} end */
     async function readRange(start, end) {
       checkAbort(signal);
+
       if (
         !Number.isSafeInteger(start) ||
         !Number.isSafeInteger(end) ||
@@ -50,20 +63,27 @@ export async function openImportFile(file_path, { signal } = {}) {
         end > size
       )
         throw new RangeError("The requested file range is outside the input.");
+
       const bytes = new Uint8Array(end - start);
+
       for (let offset = 0; offset < bytes.length; ) {
         checkAbort(signal);
+
         const { bytesRead: count } = await handle.read(
           bytes,
           offset,
           bytes.length - offset,
           start + offset
         );
+
         if (!count) throw changedInput();
+
         offset += count;
       }
+
       return bytes;
     }
+
     /** @satisfies {import("./import.generated.js").ImportSource} */
     const source = {
       name: basename(file_path),
@@ -72,25 +92,31 @@ export async function openImportFile(file_path, { signal } = {}) {
         await assertUnchanged();
         for (let offset = 0; offset < size; ) {
           const end = Math.min(size, offset + 64 * 1024);
+
           yield await readRange(offset, end);
           offset = end;
         }
+
         // Run before the row iterator returns, so its final partial batch cannot precede this check.
         await assertUnchanged();
       },
       async read(start, end) {
         await assertUnchanged();
+
         const bytes = await readRange(start, end);
+
         await assertUnchanged();
         return bytes;
       }
     };
+
     await assertUnchanged();
     return {
       source: Object.freeze(source),
       assertUnchanged,
       async cleanup() {
         if (is_closed) return;
+
         is_closed = true;
         await handle.close();
       }
@@ -121,32 +147,48 @@ function sameFile(first, second) {
  */
 export async function snapshotImportFile(file_path, { signal, temporary_root = tmpdir() } = {}) {
   checkAbort(signal);
+
   const directory = await mkdtemp(join(temporary_root, "tailglow-import-"));
   let original;
   let snapshot;
   let is_complete = false;
+
   try {
     await chmod(directory, 0o700);
     original = await open(file_path, constants.O_RDONLY | constants.O_NONBLOCK);
+
     const before = await original.stat({ bigint: true });
+
     if (!before.isFile()) throw new Error("Import input must be a regular file.");
+
     const snapshot_path = join(directory, "input");
+
     snapshot = await open(snapshot_path, "wx", 0o600);
     await snapshot.chmod(0o600);
+
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let copied_bytes = 0;
+
     for (;;) {
       checkAbort(signal);
+
       const { bytesRead: bytes_read } = await original.read(buffer, 0, buffer.length, null);
+
       if (!bytes_read) break;
+
       copied_bytes += bytes_read;
+
       if (BigInt(copied_bytes) > before.size)
         throw changedInput("Input changed while making its private snapshot.");
+
       await snapshot.writeFile(buffer.subarray(0, bytes_read));
     }
+
     checkAbort(signal);
+
     const after = await original.stat({ bigint: true });
     const current = await stat(file_path, { bigint: true });
+
     if (
       !sameFile(before, after) ||
       !sameFile(before, current) ||
@@ -154,13 +196,17 @@ export async function snapshotImportFile(file_path, { signal, temporary_root = t
     ) {
       throw changedInput("Input changed while making its private snapshot.");
     }
+
     if ((await snapshot.stat({ bigint: true })).size !== before.size)
       throw new Error("The private snapshot size differs from the input file.");
+
     await snapshot.close();
     snapshot = undefined;
     await original.close();
     original = undefined;
+
     const input = await openImportFile(snapshot_path, { signal });
+
     is_complete = true;
     return {
       source: Object.freeze({ ...input.source, name: basename(file_path) }),
@@ -176,6 +222,7 @@ export async function snapshotImportFile(file_path, { signal, temporary_root = t
   } finally {
     await snapshot?.close().catch(() => {});
     await original?.close().catch(() => {});
+
     if (!is_complete) await rm(directory, { recursive: true, force: true });
   }
 }

package/src/import-worker.generated.js

@@ -208,7 +208,11 @@ class XmlStreamParser {
       this._error("Parser failed during callback", "STATE");
   }
   _input(chunk) {
-    const mode = typeof chunk === "string" ? "string" : chunk instanceof Uint8Array ? "bytes" : "";
+    let mode = "";
+    if (typeof chunk === "string")
+      mode = "string";
+    else if (chunk instanceof Uint8Array)
+      mode = "bytes";
     if (!mode)
       throw new TypeError("XML input must be a string or Uint8Array");
     if (!chunk.length)

package/src/import.generated.js

@@ -1695,7 +1695,11 @@ class XmlStreamParser {
       this._error("Parser failed during callback", "STATE");
   }
   _input(chunk) {
-    const mode = typeof chunk === "string" ? "string" : chunk instanceof Uint8Array ? "bytes" : "";
+    let mode = "";
+    if (typeof chunk === "string")
+      mode = "string";
+    else if (chunk instanceof Uint8Array)
+      mode = "bytes";
     if (!mode)
       throw new TypeError("XML input must be a string or Uint8Array");
     if (!chunk.length)

package/src/index.js

@@ -81,6 +81,7 @@ export function parseFlags(argv) {
 /** @param {string} token */
 function quoteToken(token) {
   const safe = sanitizeText(token);
+
   return /^[A-Za-z0-9._:/=-]+$/.test(safe) ? safe : `'${safe.replaceAll("'", `'\\''`)}'`;
 }
 
@@ -106,6 +107,7 @@ export function buildResumeCommand(argv, cursor) {
     // The key must never be echoed, and the old cursor is about to be replaced.
     if (flag === "api-key" || flag === "after") {
       if (!token.includes("=") && PARSER_OPTIONS[flag]?.type === "string") index += 1;
+
       continue;
     }
 
@@ -121,6 +123,7 @@ export function buildResumeCommand(argv, cursor) {
  */
 function readFlag(flags, flag) {
   const value = flags[flag];
+
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
@@ -158,6 +161,7 @@ function resolvePath(command, { flags, config }) {
       missing.push(name);
       return current;
     }
+
     if (UNSAFE_PATH_VALUES.has(value)) {
       unsafe.push(name);
       return current;
@@ -212,8 +216,10 @@ async function confirmDestructive(command, flags) {
  */
 export async function run(argv, login_context = createLoginContext()) {
   const { values: flags, positionals } = parseFlags(argv);
+
   if (positionals[0] === "import") {
     const { runImportCommand } = await import("./import-command.js");
+
     return runImportCommand(argv);
   }
 
@@ -230,20 +236,26 @@ export async function run(argv, login_context = createLoginContext()) {
 
     if (flags.version) {
       const version = await readCliVersion();
+
       return inform(version, { version });
     }
 
     const [resource, name, ...rest] = positionals;
+
     if (resource === "help") {
       if (name) return fail("Run `tglow <resource> <command> --help` for command help.", flags);
+
       return inform(renderRootHelp(), describeForMachines());
     }
+
     if (!resource) {
       if (await shouldOfferLogin(flags, login_context)) {
         return await runLoginCommand([], flags, login_context);
       }
+
       return inform(renderRootHelp(), describeForMachines());
     }
+
     if (resource === "config") return await runConfigCommand([name, ...rest], flags);
     if (resource === "login") return await runLoginCommand([name, ...rest], flags, login_context);
     if (resource === "logout") return await runLogoutCommand([name, ...rest], flags);
@@ -251,10 +263,12 @@ export async function run(argv, login_context = createLoginContext()) {
     if (resource === "docs") {
       // Loaded only here: the bundled docs are about 600 KB that every other command would parse.
       const { runDocsCommand } = await import("./docs-command.js");
+
       return runDocsCommand([name, ...rest], flags);
     }
 
     const commands = CLI_COMMANDS.filter((entry) => entry.resource === resource);
+
     if (commands.length === 0) {
       return fail(`Unknown resource "${resource}". Run \`tglow help\` for the list.`, flags);
     }
@@ -264,6 +278,7 @@ export async function run(argv, login_context = createLoginContext()) {
     }
 
     const command = commands.find((entry) => entry.command === name);
+
     if (!command) {
       return fail(
         `Unknown command "${resource} ${name}". ` +
@@ -271,6 +286,7 @@ export async function run(argv, login_context = createLoginContext()) {
         flags
       );
     }
+
     if (flags.help) return inform(renderCommandHelp(command), describeForMachines({ command }));
 
     const config = await loadConfig();
@@ -279,11 +295,13 @@ export async function run(argv, login_context = createLoginContext()) {
 
     if (unsafe.length > 0) {
       const named = unsafe.map((entry) => `--${toFlagName(entry)}`).join(", ");
+
       return fail(
         `${named} cannot be "." or "..". Those resolve to a different endpoint than this command calls.`,
         flags
       );
     }
+
     if (missing.length > 0) {
       // Only project and team have a stored default, so only they can be answered with `config set`.
       // Suggesting it for a missing source or metric id sends the reader after a setting that does
@@ -303,6 +321,7 @@ export async function run(argv, login_context = createLoginContext()) {
     const { query, body, unknown } = buildRequestParts(command, flags, {
       consumed_path_fields: consumed
     });
+
     if (unknown.length > 0) {
       return fail(
         `Unknown flag${unknown.length === 1 ? "" : "s"}: ${unknown.map((entry) => `--${entry}`).join(", ")}.\n` +
@@ -330,6 +349,7 @@ export async function run(argv, login_context = createLoginContext()) {
           flags
         );
       }
+
       // `--all` owns paging: it walks forwards from `after` and sizes each page itself. `--before`
       // asks the API to page the other way at the same time, and `--limit` states a page size that
       // the cap then has to override. Refusing both beats silently reinterpreting either.
@@ -339,6 +359,7 @@ export async function run(argv, login_context = createLoginContext()) {
           flags
         );
       }
+
       if (query.limit !== undefined) {
         return fail("--limit cannot be combined with --all. Use --max to cap the total.", flags);
       }
@@ -346,6 +367,7 @@ export async function run(argv, login_context = createLoginContext()) {
       // `--max` written bare parses as `true`, and checking `Number(raw)` rather than the text lets
       // `1e-400` and `1.0000000000000001` through as whole numbers.
       const raw_max = flags.max === undefined ? String(CLI_CONFIGS.DEFAULT_MAX_RECORDS) : flags.max;
+
       if (typeof raw_max !== "string" || !isIntegerText(raw_max) || Number(raw_max) < 1) {
         return fail(`--max must be a whole number of at least 1, received "${raw_max}".`, flags);
       }
@@ -389,9 +411,11 @@ export async function run(argv, login_context = createLoginContext()) {
       config,
       path_team_id
     });
+
     return { output: renderResponse(payload, flags), code: 0 };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
+
     // `tglow docs` answers in text unless --json was given, including for a flag the shared checks
     // above rejected before it was dispatched.
     if (positionals[0] === "docs") {
@@ -400,6 +424,7 @@ export async function run(argv, login_context = createLoginContext()) {
         code: 1
       };
     }
+
     return fail(message, flags);
   }
 }
@@ -413,6 +438,7 @@ export async function run(argv, login_context = createLoginContext()) {
  */
 function isEntrypoint() {
   if (!process.argv[1]) return false;
+
   try {
     return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
   } catch {
@@ -428,24 +454,31 @@ if (isEntrypoint()) {
   // `tglow records list --all --json | jq` would receive a JSON document cut off mid-value, which
   // is exactly the invariant this CLI sells. Set the code and let the write drain instead.
   let json = shouldEmitJson({});
+
   try {
     const argv = process.argv.slice(2);
     const { values: flags, positionals } = parseFlags(argv);
+
     json = shouldEmitJson({ json: flags.json === true || flags.json === "true" });
+
     const result = await run(argv);
     const message =
       !flags.help &&
       ((!positionals[0] && result.output !== renderRootHelp()) ||
         ["login", "logout", "whoami"].includes(positionals[0]) ||
         (positionals[0] === "config" && ["set", "unset"].includes(positionals[1])));
+
     process.exitCode = result.code;
+
     if (positionals[0] === "import" && json) {
       // Import reports include partial delivery state, so scripts always receive one stdout JSON document.
       process.stdout.write(result.output + "\n");
     } else writeCommandResult(result, { json, message });
   } catch (err) {
     process.exitCode = 1;
+
     const message = err instanceof Error ? err.message : String(err);
+
     writeCommandResult(
       { output: json ? JSON.stringify({ error: message }) : message, code: 1 },
       { json }
@@ -455,6 +488,7 @@ if (isEntrypoint()) {
   // A failed command in JSON mode answers with one JSON document on stderr, so it gets no notice.
   // Nothing about the notice may fail a finished command, a closed stderr included.
   const notice = await update_notice;
+
   if (notice && !(json && process.exitCode !== 0)) {
     process.stderr.on("error", () => {});
     try {