@tailglow/cli 0.9.6 → 0.9.16

package/src/request.js

@@ -41,11 +41,14 @@ export async function buildRequestHeaders({ secret, team_id, env = process.env }
 
   // fetch throws on some header characters, such as a line break, so only a plain name is sent.
   const terminal = env.TERM_PROGRAM?.trim();
+
   if (terminal && /^[\w .+-]{1,32}$/.test(terminal)) {
     headers["x-tailglow-client-terminal"] = terminal;
   }
+
   if (secret) headers.Authorization = `Bearer ${secret}`;
   if (team_id) headers["x-tailglow-team-id"] = team_id;
+
   return headers;
 }
 
@@ -79,6 +82,7 @@ export async function sendRequest({ method, url, headers, body, fetch_impl = fet
 
   /** @type {import("./types.d.ts").ApiResponse | null} */
   let payload = null;
+
   if (text.trim() !== "") {
     try {
       payload = readEnvelope(text);
@@ -86,6 +90,7 @@ export async function sendRequest({ method, url, headers, body, fetch_impl = fet
       payload = null;
     }
   }
+
   return { status: response.status, ok: response.ok, payload };
 }
 
@@ -104,11 +109,13 @@ export function formatValidationIssues(message) {
 
   /** @type {unknown} */
   let issues;
+
   try {
     issues = JSON.parse(message);
   } catch {
     return null;
   }
+
   if (!Array.isArray(issues) || issues.length === 0) return null;
 
   // Each piece is sanitized on its own, because the assembled string carries real newlines that the
@@ -122,6 +129,7 @@ export function formatValidationIssues(message) {
     const detail = sanitizeText(
       typeof issue?.message === "string" ? issue.message : JSON.stringify(issue)
     );
+
     return where ? `  ${where}: ${detail}` : `  ${detail}`;
   });
 
@@ -148,14 +156,17 @@ function describeFailure({ status, message, method, url, code = null, is_login =
   // Parsed BEFORE sanitizing: escaping the newlines the API embedded would stop it parsing at all,
   // which is how the first attempt at this silently fell through to the raw dump.
   const issues = formatValidationIssues(String(message));
+
   if (issues) return `${status} ${issues}`;
 
   const text = sanitizeText(String(message));
+
   if (status === 404) {
     return `${status} ${text}\nNothing answers ${method} ${sanitizeText(url.pathname)}.`;
   }
 
   const advice = is_login && code ? LOGIN_REFUSAL_ADVICE[code] : null;
+
   if (advice && (status === 401 || status === 403)) return `${status} ${text}\n${advice}`;
 
   return `${status} ${text}`;
@@ -173,6 +184,7 @@ function describeFailure({ status, message, method, url, code = null, is_login =
 function readEnvelope(text) {
   /** @type {unknown} */
   const value = JSON.parse(text);
+
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 
   return /** @type {import("./types.d.ts").ApiResponse} */ (value);
@@ -201,8 +213,10 @@ export async function requestApi({
   path_team_id = null
 }) {
   const url = new URL(path, resolveApiUrl({ flags, config }));
+
   for (const [key, value] of Object.entries(query)) {
     if (value === undefined || value === null) continue;
+
     url.searchParams.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
   }
 
@@ -221,6 +235,7 @@ export async function requestApi({
   /** @type {import("./types.d.ts").ApiResponse | null} */
   let payload = null;
   let parsed = true;
+
   if (body_text.trim() !== "") {
     try {
       payload = readEnvelope(body_text);
@@ -231,6 +246,7 @@ export async function requestApi({
 
   if (!response.ok) {
     const message = payload?.error?.message || payload?.message || response.statusText;
+
     throw new Error(
       describeFailure({
         status: response.status,
@@ -311,9 +327,11 @@ export async function requestAllPages({
     });
 
     const page = Array.isArray(payload?.data) ? payload.data : [];
+
     collected.push(...page);
 
     const next = payload?.pagination?.next_cursor ?? null;
+
     if (!next || page.length === 0) return { data: collected, truncated: false, next_cursor: null };
 
     // Checked BEFORE the cap. A page that both reaches the cap and hands back a cursor already used

package/src/update-check.js

@@ -20,10 +20,13 @@ function parseVersion(version) {
 export function isNewerVersion(candidate, installed) {
   const next = parseVersion(candidate);
   const current = parseVersion(installed);
+
   if (!next || !current) return false;
+
   for (let index = 0; index < 3; index += 1) {
     if (next[index] !== current[index]) return next[index] > current[index];
   }
+
   return false;
 }
 
@@ -37,13 +40,20 @@ export function isNewerVersion(candidate, installed) {
 async function readUpdateCheck(path) {
   /** @type {import("node:fs/promises").FileHandle | null} */
   let handle = null;
+
   try {
     handle = await fs.open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+
     const stats = await handle.stat();
+
     if (!stats.isFile() || stats.size > CLI_CONFIGS.UPDATE_CHECK_MAX_BYTES) return null;
+
     const stored = JSON.parse(await handle.readFile("utf-8"));
+
     if (typeof stored?.checked_at !== "number") return null;
+
     const latest_version = typeof stored.latest_version === "string" ? stored.latest_version : null;
+
     return { checked_at: stored.checked_at, latest_version };
   } catch {
     return null;
@@ -56,6 +66,7 @@ async function readUpdateCheck(path) {
 function readManifestVersion(body) {
   try {
     const manifest = JSON.parse(body);
+
     return typeof manifest?.version === "string" ? manifest.version : null;
   } catch {
     return null;
@@ -76,18 +87,23 @@ function fetchLatestVersion() {
       { signal: AbortSignal.timeout(CLI_CONFIGS.UPDATE_CHECK_TIMEOUT_MS) },
       (response) => {
         let body = "";
+
         response.setEncoding("utf-8");
         response.on("data", (chunk) => {
           body += chunk;
+
           if (body.length > CLI_CONFIGS.UPDATE_CHECK_MAX_BYTES) request.destroy();
         });
+
         response.on("end", () =>
           resolve(response.statusCode === 200 ? readManifestVersion(body) : null)
         );
+
         // Settles an aborted or destroyed response; after `end` the promise has already resolved.
         response.on("close", () => resolve(null));
       }
     );
+
     request.on("error", () => resolve(null));
     // A request can also end with no response and no error, such as an upgrade nothing accepts.
     request.on("close", () => resolve(null));
@@ -114,19 +130,25 @@ export async function readUpdateNotice({
   path = CLI_CONFIGS.UPDATE_CHECK_PATH
 } = {}) {
   if (env.CI || env.TAILGLOW_NO_UPDATE_CHECK) return null;
+
   try {
     let check = await readUpdateCheck(path);
+
     if (!check || now - check.checked_at >= CLI_CONFIGS.UPDATE_CHECK_INTERVAL_MS) {
       const previous = check?.latest_version ?? null;
+
       // Recorded before npm is asked: an attempt that cannot be recorded is not made, so a machine
       // that cannot write the file is never slowed down on every command.
       await saveConfig({ checked_at: now, latest_version: previous }, path);
       check = { checked_at: now, latest_version: (await fetch_latest_version()) ?? previous };
+
       if (check.latest_version !== previous) await saveConfig(check, path);
     }
 
     const installed = await readCliVersion();
+
     if (!check.latest_version || !isNewerVersion(check.latest_version, installed)) return null;
+
     return (
       `tglow ${check.latest_version} is available (you have ${installed}). ` +
       "Update with `npm install -g @tailglow/cli@latest`, or run `npx @tailglow/cli@latest`."