@flakiness/sdk 0.95.0 → 0.97.0

package/lib/cli/cli.js

@@ -1,238 +1,751 @@
 #!/usr/bin/env node
 
-// src/cli/cli.ts
-import { Command, Option } from "commander";
-import fs10 from "fs";
-import path8 from "path";
-
-// src/flakinessSession.ts
-import fs2 from "fs/promises";
-import os2 from "os";
-import path from "path";
-
-// ../server/lib/common/typedHttp.js
-var TypedHTTP;
-((TypedHTTP2) => {
-  TypedHTTP2.StatusCodes = {
-    Informational: {
-      CONTINUE: 100,
-      SWITCHING_PROTOCOLS: 101,
-      PROCESSING: 102,
-      EARLY_HINTS: 103
-    },
-    Success: {
-      OK: 200,
-      CREATED: 201,
-      ACCEPTED: 202,
-      NON_AUTHORITATIVE_INFORMATION: 203,
-      NO_CONTENT: 204,
-      RESET_CONTENT: 205,
-      PARTIAL_CONTENT: 206,
-      MULTI_STATUS: 207
-    },
-    Redirection: {
-      MULTIPLE_CHOICES: 300,
-      MOVED_PERMANENTLY: 301,
-      MOVED_TEMPORARILY: 302,
-      SEE_OTHER: 303,
-      NOT_MODIFIED: 304,
-      USE_PROXY: 305,
-      TEMPORARY_REDIRECT: 307,
-      PERMANENT_REDIRECT: 308
-    },
-    ClientErrors: {
-      BAD_REQUEST: 400,
-      UNAUTHORIZED: 401,
-      PAYMENT_REQUIRED: 402,
-      FORBIDDEN: 403,
-      NOT_FOUND: 404,
-      METHOD_NOT_ALLOWED: 405,
-      NOT_ACCEPTABLE: 406,
-      PROXY_AUTHENTICATION_REQUIRED: 407,
-      REQUEST_TIMEOUT: 408,
-      CONFLICT: 409,
-      GONE: 410,
-      LENGTH_REQUIRED: 411,
-      PRECONDITION_FAILED: 412,
-      REQUEST_TOO_LONG: 413,
-      REQUEST_URI_TOO_LONG: 414,
-      UNSUPPORTED_MEDIA_TYPE: 415,
-      REQUESTED_RANGE_NOT_SATISFIABLE: 416,
-      EXPECTATION_FAILED: 417,
-      IM_A_TEAPOT: 418,
-      INSUFFICIENT_SPACE_ON_RESOURCE: 419,
-      METHOD_FAILURE: 420,
-      MISDIRECTED_REQUEST: 421,
-      UNPROCESSABLE_ENTITY: 422,
-      LOCKED: 423,
-      FAILED_DEPENDENCY: 424,
-      UPGRADE_REQUIRED: 426,
-      PRECONDITION_REQUIRED: 428,
-      TOO_MANY_REQUESTS: 429,
-      REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-      UNAVAILABLE_FOR_LEGAL_REASONS: 451
-    },
-    ServerErrors: {
-      INTERNAL_SERVER_ERROR: 500,
-      NOT_IMPLEMENTED: 501,
-      BAD_GATEWAY: 502,
-      SERVICE_UNAVAILABLE: 503,
-      GATEWAY_TIMEOUT: 504,
-      HTTP_VERSION_NOT_SUPPORTED: 505,
-      INSUFFICIENT_STORAGE: 507,
-      NETWORK_AUTHENTICATION_REQUIRED: 511
-    }
-  };
-  const AllErrorCodes = {
-    ...TypedHTTP2.StatusCodes.ClientErrors,
-    ...TypedHTTP2.StatusCodes.ServerErrors
-  };
-  class HttpError extends Error {
-    constructor(status, message) {
-      super(message);
-      this.status = status;
+// ../node_modules/vlq/src/index.js
+var char_to_integer = {};
+var integer_to_char = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(char, i) {
+  char_to_integer[char] = i;
+  integer_to_char[i] = char;
+});
+function decode(string) {
+  let result = [];
+  let shift = 0;
+  let value = 0;
+  for (let i = 0; i < string.length; i += 1) {
+    let integer = char_to_integer[string[i]];
+    if (integer === void 0) {
+      throw new Error("Invalid character (" + string[i] + ")");
     }
-    static withCode(code, message) {
-      const statusCode = AllErrorCodes[code];
-      const defaultMessage = code.split("_").map((word) => word.charAt(0) + word.slice(1).toLowerCase()).join(" ");
-      return new HttpError(statusCode, message ?? defaultMessage);
+    const has_continuation_bit = integer & 32;
+    integer &= 31;
+    value += integer << shift;
+    if (has_continuation_bit) {
+      shift += 5;
+    } else {
+      const should_negate = value & 1;
+      value >>>= 1;
+      if (should_negate) {
+        result.push(value === 0 ? -2147483648 : -value);
+      } else {
+        result.push(value);
+      }
+      value = shift = 0;
     }
   }
-  TypedHTTP2.HttpError = HttpError;
-  function isInformationalResponse(response) {
-    return response.status >= 100 && response.status < 200;
+  return result;
+}
+function encode(value) {
+  if (typeof value === "number") {
+    return encode_integer(value);
   }
-  TypedHTTP2.isInformationalResponse = isInformationalResponse;
-  function isSuccessResponse(response) {
-    return response.status >= 200 && response.status < 300;
+  let result = "";
+  for (let i = 0; i < value.length; i += 1) {
+    result += encode_integer(value[i]);
   }
-  TypedHTTP2.isSuccessResponse = isSuccessResponse;
-  function isRedirectResponse(response) {
-    return response.status >= 300 && response.status < 400;
+  return result;
+}
+function encode_integer(num) {
+  let result = "";
+  if (num < 0) {
+    num = -num << 1 | 1;
+  } else {
+    num <<= 1;
   }
-  TypedHTTP2.isRedirectResponse = isRedirectResponse;
-  function isErrorResponse(response) {
-    return response.status >= 400 && response.status < 600;
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) {
+      clamped |= 32;
+    }
+    result += integer_to_char[clamped];
+  } while (num > 0);
+  return result;
+}
+
+// ../server/lib/common/heap.js
+var Heap = class _Heap {
+  constructor(_cmp, elements = []) {
+    this._cmp = _cmp;
+    this._heap = elements.map(([element, score]) => ({ element, score }));
+    for (let idx = this._heap.length - 1; idx >= 0; --idx)
+      this._down(idx);
+  }
+  static createMin(elements = []) {
+    return new _Heap((a, b) => a - b, elements);
+  }
+  static createMax(elements = []) {
+    return new _Heap((a, b) => b - a, elements);
+  }
+  _heap = [];
+  _up(idx) {
+    const e = this._heap[idx];
+    while (idx > 0) {
+      const parentIdx = idx - 1 >>> 1;
+      if (this._cmp(this._heap[parentIdx].score, e.score) <= 0)
+        break;
+      this._heap[idx] = this._heap[parentIdx];
+      idx = parentIdx;
+    }
+    this._heap[idx] = e;
+  }
+  _down(idx) {
+    const N = this._heap.length;
+    const e = this._heap[idx];
+    while (true) {
+      const leftIdx = idx * 2 + 1;
+      const rightIdx = idx * 2 + 2;
+      let smallestIdx;
+      if (leftIdx < N && rightIdx < N) {
+        smallestIdx = this._cmp(this._heap[leftIdx].score, this._heap[rightIdx].score) < 0 ? leftIdx : rightIdx;
+      } else if (leftIdx < N) {
+        smallestIdx = leftIdx;
+      } else if (rightIdx < N) {
+        smallestIdx = rightIdx;
+      } else {
+        break;
+      }
+      if (this._cmp(e.score, this._heap[smallestIdx].score) < 0)
+        break;
+      this._heap[idx] = this._heap[smallestIdx];
+      idx = smallestIdx;
+    }
+    this._heap[idx] = e;
   }
-  TypedHTTP2.isErrorResponse = isErrorResponse;
-  function info(status) {
-    return { status };
+  push(element, score) {
+    this._heap.push({ element, score });
+    this._up(this._heap.length - 1);
   }
-  TypedHTTP2.info = info;
-  function ok(data, status) {
-    return {
-      status: status ?? TypedHTTP2.StatusCodes.Success.OK,
-      data
-    };
+  get size() {
+    return this._heap.length;
   }
-  TypedHTTP2.ok = ok;
-  function redirect(url, status = 302) {
-    return { status, url };
+  peekEntry() {
+    return this._heap.length ? [this._heap[0].element, this._heap[0].score] : void 0;
   }
-  TypedHTTP2.redirect = redirect;
-  function error(message, status = TypedHTTP2.StatusCodes.ServerErrors.INTERNAL_SERVER_ERROR) {
-    return { status, message };
+  popEntry() {
+    if (!this._heap.length)
+      return void 0;
+    const entry = this._heap[0];
+    const last = this._heap.pop();
+    if (!this._heap.length)
+      return [entry.element, entry.score];
+    this._heap[0] = last;
+    this._down(0);
+    return [entry.element, entry.score];
   }
-  TypedHTTP2.error = error;
-  class Router {
-    constructor(_resolveContext) {
-      this._resolveContext = _resolveContext;
+};
+
+// ../server/lib/common/sequence.js
+var Sequence = class _Sequence {
+  constructor(_seek, length) {
+    this._seek = _seek;
+    this.length = length;
+  }
+  static fromList(a) {
+    return new _Sequence(
+      function(pos) {
+        return {
+          next() {
+            if (pos >= a.length)
+              return { done: true, value: void 0 };
+            return { done: false, value: a[pos++] };
+          }
+        };
+      },
+      a.length
+    );
+  }
+  static chain(seqs) {
+    const leftsums = [];
+    let length = 0;
+    for (let i = 0; i < seqs.length; ++i) {
+      length += seqs[i].length;
+      leftsums.push(length);
     }
-    static create() {
-      return new Router(async (e) => e.ctx);
+    return new _Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        let idx = _Sequence.fromList(leftsums).partitionPoint((x) => x <= fromIdx);
+        if (idx >= seqs.length) {
+          return {
+            next: () => ({ done: true, value: void 0 })
+          };
+        }
+        let it = seqs[idx].seek(idx > 0 ? fromIdx - leftsums[idx - 1] : fromIdx);
+        return {
+          next() {
+            let result = it.next();
+            while (result.done && ++idx < seqs.length) {
+              it = seqs[idx].seek(0);
+              result = it.next();
+            }
+            return result.done ? result : { done: false, value: [result.value, idx] };
+          }
+        };
+      },
+      length
+    );
+  }
+  static merge(sequences, cmp) {
+    const length = sequences.reduce((acc, seq) => acc + seq.length, 0);
+    return new _Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        const offsets = quickAdvance(sequences, cmp, fromIdx);
+        const entries = [];
+        for (let i = 0; i < sequences.length; ++i) {
+          const seq = sequences[i];
+          const it = seq.seek(offsets[i]);
+          const itval = it.next();
+          if (!itval.done)
+            entries.push([it, itval.value]);
+        }
+        const heap = new Heap(cmp, entries);
+        return {
+          next() {
+            if (!heap.size)
+              return { done: true, value: void 0 };
+            ++fromIdx;
+            const [it, e] = heap.popEntry();
+            const itval = it.next();
+            if (!itval.done)
+              heap.push(it, itval.value);
+            return { done: false, value: e };
+          }
+        };
+      },
+      length
+    );
+  }
+  static EMPTY = new _Sequence(function* () {
+  }, 0);
+  seek(idx) {
+    const it = this._seek(idx);
+    it[Symbol.iterator] = () => it;
+    return it;
+  }
+  get(idx) {
+    return this.seek(idx).next().value;
+  }
+  map(mapper) {
+    const originalSeek = this._seek;
+    return new _Sequence(
+      function(idx) {
+        const it = originalSeek(idx);
+        return {
+          next() {
+            const next = it.next();
+            if (next.done)
+              return next;
+            return { done: false, value: mapper(next.value) };
+          }
+        };
+      },
+      this.length
+    );
+  }
+  /** Number of elements in sequence that are <= comparator. Only works on sorted sequences. */
+  partitionPoint(predicate) {
+    let lo = 0, hi = this.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (predicate(this.get(mid)))
+        lo = mid + 1;
+      else
+        hi = mid;
     }
-    rawMethod(method, route) {
-      return {
-        [method]: {
-          method,
-          input: route.input,
-          etag: route.etag,
-          resolveContext: this._resolveContext,
-          handler: route.handler
+    return lo;
+  }
+};
+function quickAdvance(sequences, cmp, k) {
+  const offsets = new Map(sequences.map((s) => [s, 0]));
+  while (offsets.size && k > 0) {
+    const t2 = offsets.size;
+    const x = Math.max(Math.floor(k / t2 / 2), 1);
+    const entries = [];
+    for (const [seq, offset] of offsets) {
+      if (offset + x <= seq.length)
+        entries.push([seq, seq.get(offset + x - 1)]);
+    }
+    const heap = new Heap(cmp, entries);
+    while (heap.size && k > 0 && (x === 1 || k >= x * t2)) {
+      k -= x;
+      const [seq] = heap.popEntry();
+      const offset = offsets.get(seq) + x;
+      if (offset === seq.length)
+        offsets.delete(seq);
+      else
+        offsets.set(seq, offset);
+      if (offset + x <= seq.length)
+        heap.push(seq, seq.get(offset + x - 1));
+    }
+  }
+  return sequences.map((seq) => offsets.get(seq) ?? seq.length);
+}
+
+// ../server/lib/common/ranges.js
+var Ranges;
+((Ranges2) => {
+  Ranges2.EMPTY = [];
+  Ranges2.FULL = [-Infinity, Infinity];
+  function isFull(ranges) {
+    return ranges.length === 2 && Object.is(ranges[0], -Infinity) && Object.is(ranges[1], Infinity);
+  }
+  Ranges2.isFull = isFull;
+  function compress(ranges) {
+    if (!ranges.length)
+      return "";
+    if (isInfinite(ranges))
+      throw new Error("Compression of infinite ranges is not supported");
+    const prepared = [];
+    let last = ranges[0] - 1;
+    prepared.push(last);
+    for (let i = 0; i < ranges.length; i += 2) {
+      if (ranges[i] === ranges[i + 1]) {
+        prepared.push(-(ranges[i] - last));
+      } else {
+        prepared.push(ranges[i] - last);
+        prepared.push(ranges[i + 1] - ranges[i]);
+      }
+      last = ranges[i + 1];
+    }
+    return encode(prepared);
+  }
+  Ranges2.compress = compress;
+  function decompress(compressed) {
+    if (!compressed.length)
+      return [];
+    const prepared = decode(compressed);
+    const result = [];
+    let last = prepared[0];
+    for (let i = 1; i < prepared.length; ++i) {
+      if (prepared[i] < 0) {
+        result.push(-prepared[i] + last);
+        result.push(-prepared[i] + last);
+        last -= prepared[i];
+      } else {
+        result.push(prepared[i] + last);
+        last += prepared[i];
+      }
+    }
+    return result;
+  }
+  Ranges2.decompress = decompress;
+  function toString(ranges) {
+    const tokens = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      if (ranges[i] === ranges[i + 1])
+        tokens.push(ranges[i]);
+      else
+        tokens.push(`${ranges[i]}-${ranges[i + 1]}`);
+    }
+    if (!tokens.length)
+      return `[]`;
+    return `[ ` + tokens.join(", ") + ` ]`;
+  }
+  Ranges2.toString = toString;
+  function popInplace(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot pop from infinite ranges!");
+    const last = ranges.at(-1);
+    const prelast = ranges.at(-2);
+    if (last === void 0 || prelast === void 0)
+      return void 0;
+    if (last === prelast) {
+      ranges.pop();
+      ranges.pop();
+    } else {
+      ranges[ranges.length - 1] = last - 1;
+    }
+    return last;
+  }
+  Ranges2.popInplace = popInplace;
+  function* iterate(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot iterate infinite ranges!");
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        yield j;
+    }
+  }
+  Ranges2.iterate = iterate;
+  function toSortedList(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot convert infinite ranges!");
+    const list = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        list.push(j);
+    }
+    return list;
+  }
+  Ranges2.toSortedList = toSortedList;
+  function toInt32Array(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot convert infinite ranges!");
+    const result = new Int32Array(cardinality(ranges));
+    let idx = 0;
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        result[idx++] = j;
+    }
+    return result;
+  }
+  Ranges2.toInt32Array = toInt32Array;
+  function fromList(x) {
+    for (let i = 0; i < x.length - 1; ++i) {
+      if (x[i] > x[i + 1]) {
+        x = x.toSorted((a, b) => a - b);
+        break;
+      }
+    }
+    return fromSortedList(x);
+  }
+  Ranges2.fromList = fromList;
+  function from(x) {
+    return [x, x];
+  }
+  Ranges2.from = from;
+  function fromSortedList(sorted) {
+    const ranges = [];
+    let rangeStart = 0;
+    for (let i = 1; i <= sorted.length; ++i) {
+      if (i < sorted.length && sorted[i] - sorted[i - 1] <= 1)
+        continue;
+      ranges.push(sorted[rangeStart], sorted[i - 1]);
+      rangeStart = i;
+    }
+    return ranges;
+  }
+  Ranges2.fromSortedList = fromSortedList;
+  function isInfinite(ranges) {
+    return ranges.length > 0 && (Object.is(ranges[0], Infinity) || Object.is(ranges[ranges.length - 1], Infinity));
+  }
+  Ranges2.isInfinite = isInfinite;
+  function includes(ranges, e) {
+    if (!ranges.length)
+      return false;
+    if (e < ranges[0] || ranges[ranges.length - 1] < e)
+      return false;
+    if (ranges.length < 17) {
+      for (let i = 0; i < ranges.length - 1; i += 2) {
+        if (ranges[i] <= e && e <= ranges[i + 1])
+          return true;
+      }
+      return false;
+    }
+    let lo = 0, hi = ranges.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (ranges[mid] === e)
+        return true;
+      if (ranges[mid] < e)
+        lo = mid + 1;
+      else
+        hi = mid;
+    }
+    return (lo & 1) !== 0;
+  }
+  Ranges2.includes = includes;
+  function cardinality(ranges) {
+    if (isInfinite(ranges))
+      return Infinity;
+    let sum = 0;
+    for (let i = 0; i < ranges.length - 1; i += 2)
+      sum += ranges[i + 1] - ranges[i] + 1;
+    return sum;
+  }
+  Ranges2.cardinality = cardinality;
+  function offset(ranges, offset2) {
+    return ranges.map((x) => x + offset2);
+  }
+  Ranges2.offset = offset;
+  function intersect(ranges1, ranges2) {
+    const ranges = [];
+    if (!ranges1.length || !ranges2.length)
+      return ranges;
+    if (ranges1[ranges1.length - 1] < ranges2[0] || ranges2[ranges2.length - 1] < ranges1[0])
+      return ranges;
+    let p1 = 0;
+    let p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      if (ranges1[p1 + 1] < ranges2[p2]) {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && ranges1[p1 + offset2 * 2 + 1] < ranges2[p2])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      } else if (ranges2[p2 + 1] < ranges1[p1]) {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && ranges2[p2 + offset2 * 2 + 1] < ranges1[p1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      } else {
+        const a1 = ranges1[p1], a2 = ranges1[p1 + 1];
+        const b1 = ranges2[p2], b2 = ranges2[p2 + 1];
+        ranges.push(Math.max(a1, b1), Math.min(a2, b2));
+        if (a2 < b2) {
+          p1 += 2;
+        } else if (a2 > b2) {
+          p2 += 2;
+        } else {
+          p1 += 2;
+          p2 += 2;
         }
-      };
+      }
     }
-    get(route) {
-      return this.rawMethod("GET", {
-        ...route,
-        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
-      });
+    return ranges;
+  }
+  Ranges2.intersect = intersect;
+  function capAt(ranges, cap) {
+    const result = [];
+    for (let i = 0; i < ranges.length; i += 2) {
+      const start = ranges[i];
+      const end = ranges[i + 1];
+      if (start > cap)
+        break;
+      if (end <= cap) {
+        result.push(start, end);
+      } else {
+        result.push(start, cap);
+        break;
+      }
     }
-    post(route) {
-      return this.rawMethod("POST", {
-        ...route,
-        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
-      });
+    return result;
+  }
+  Ranges2.capAt = capAt;
+  function isIntersecting(ranges1, ranges2) {
+    if (!ranges1.length || !ranges2.length)
+      return false;
+    if (ranges1[ranges1.length - 1] < ranges2[0] || ranges2[ranges2.length - 1] < ranges1[0])
+      return false;
+    let p1 = 0;
+    let p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      const a1 = ranges1[p1], a2 = ranges1[p1 + 1];
+      const b1 = ranges2[p2], b2 = ranges2[p2 + 1];
+      if (a2 < b1) {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && ranges1[p1 + offset2 * 2 + 1] < ranges2[p2])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      } else if (b2 < a1) {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && ranges2[p2 + offset2 * 2 + 1] < ranges1[p1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      } else {
+        return true;
+      }
     }
-    use(resolveContext) {
-      return new Router(async (options) => {
-        const m = await this._resolveContext(options);
-        return resolveContext({ ...options, ctx: m });
-      });
+    return false;
+  }
+  Ranges2.isIntersecting = isIntersecting;
+  function complement(r) {
+    if (r.length === 0)
+      return [-Infinity, Infinity];
+    const result = [];
+    if (!Object.is(r[0], -Infinity))
+      result.push(-Infinity, r[0] - 1);
+    for (let i = 1; i < r.length - 2; i += 2)
+      result.push(r[i] + 1, r[i + 1] - 1);
+    if (!Object.is(r[r.length - 1], Infinity))
+      result.push(r[r.length - 1] + 1, Infinity);
+    return result;
+  }
+  Ranges2.complement = complement;
+  function subtract(ranges1, ranges2) {
+    return intersect(ranges1, complement(ranges2));
+  }
+  Ranges2.subtract = subtract;
+  function singleRange(from2, to) {
+    return [from2, to];
+  }
+  Ranges2.singleRange = singleRange;
+  function unionAll(ranges) {
+    let result = Ranges2.EMPTY;
+    for (const r of ranges)
+      result = union(result, r);
+    return result;
+  }
+  Ranges2.unionAll = unionAll;
+  function unionAll_2(rangesIterable) {
+    const ranges = Array.isArray(rangesIterable) ? rangesIterable : Array.from(rangesIterable);
+    if (ranges.length === 0)
+      return [];
+    if (ranges.length === 1)
+      return ranges[0];
+    if (ranges.length === 2)
+      return union(ranges[0], ranges[1]);
+    const seq = Sequence.merge(ranges.map((r) => intervalSequence(r)), (a, b) => a[0] - b[0]);
+    const result = [];
+    let last;
+    for (const interval of seq.seek(0)) {
+      if (!last || last[1] + 1 < interval[0]) {
+        result.push(interval);
+        last = interval;
+        continue;
+      }
+      if (last[1] < interval[1])
+        last[1] = interval[1];
+    }
+    return result.flat();
+  }
+  Ranges2.unionAll_2 = unionAll_2;
+  function intersectAll(ranges) {
+    if (!ranges.length)
+      return Ranges2.EMPTY;
+    let result = Ranges2.FULL;
+    for (const range of ranges)
+      result = Ranges2.intersect(result, range);
+    return result;
+  }
+  Ranges2.intersectAll = intersectAll;
+  function domain(ranges) {
+    if (!ranges.length)
+      return void 0;
+    return { min: ranges[0], max: ranges[ranges.length - 1] };
+  }
+  Ranges2.domain = domain;
+  function union(ranges1, ranges2) {
+    if (!ranges1.length)
+      return ranges2;
+    if (!ranges2.length)
+      return ranges1;
+    if (ranges2[0] < ranges1[0])
+      [ranges1, ranges2] = [ranges2, ranges1];
+    const r = [ranges1[0], ranges1[1]];
+    let p1 = 2, p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      if (ranges1[p1] <= ranges2[p2]) {
+        if (r[r.length - 1] + 1 < ranges1[p1]) {
+          r.push(ranges1[p1], ranges1[p1 + 1]);
+          p1 += 2;
+        } else if (r[r.length - 1] < ranges1[p1 + 1]) {
+          r[r.length - 1] = ranges1[p1 + 1];
+          p1 += 2;
+        } else {
+          p1 += 2;
+          let offset2 = 1;
+          while (p1 + offset2 * 2 + 1 < ranges1.length && r[r.length - 1] >= ranges1[p1 + offset2 * 2 + 1])
+            offset2 <<= 1;
+          p1 += offset2 >> 1 << 1;
+        }
+      } else {
+        if (r[r.length - 1] + 1 < ranges2[p2]) {
+          r.push(ranges2[p2], ranges2[p2 + 1]);
+          p2 += 2;
+        } else if (r[r.length - 1] < ranges2[p2 + 1]) {
+          r[r.length - 1] = ranges2[p2 + 1];
+          p2 += 2;
+        } else {
+          p2 += 2;
+          let offset2 = 1;
+          while (p2 + offset2 * 2 + 1 < ranges2.length && r[r.length - 1] >= ranges2[p2 + offset2 * 2 + 1])
+            offset2 <<= 1;
+          p2 += offset2 >> 1 << 1;
+        }
+      }
     }
+    while (p1 < ranges1.length - 1) {
+      if (r[r.length - 1] + 1 < ranges1[p1]) {
+        r.push(ranges1[p1], ranges1[p1 + 1]);
+        p1 += 2;
+      } else if (r[r.length - 1] < ranges1[p1 + 1]) {
+        r[r.length - 1] = ranges1[p1 + 1];
+        p1 += 2;
+      } else {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && r[r.length - 1] >= ranges1[p1 + offset2 * 2 + 1])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      }
+    }
+    while (p2 < ranges2.length - 1) {
+      if (r[r.length - 1] + 1 < ranges2[p2]) {
+        r.push(ranges2[p2], ranges2[p2 + 1]);
+        p2 += 2;
+      } else if (r[r.length - 1] < ranges2[p2 + 1]) {
+        r[r.length - 1] = ranges2[p2 + 1];
+        p2 += 2;
+      } else {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && r[r.length - 1] >= ranges2[p2 + offset2 * 2 + 1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      }
+    }
+    return r;
   }
-  TypedHTTP2.Router = Router;
-  function createClient(base, fetchCallback) {
-    function buildUrl(path9, input, options) {
-      const method = path9.at(-1);
-      const url = new URL(path9.slice(0, path9.length - 1).join("/"), base);
-      const signal = options?.signal;
-      let body = void 0;
-      if (method === "GET" && input)
-        url.searchParams.set("input", JSON.stringify(input));
-      else if (method !== "GET" && input)
-        body = JSON.stringify(input);
+  Ranges2.union = union;
+  function intervalSequence(ranges) {
+    return new Sequence(function(idx) {
       return {
-        url,
-        method,
-        headers: body ? { "Content-Type": "application/json" } : void 0,
-        body,
-        signal
+        next() {
+          if (idx * 2 >= ranges.length)
+            return { done: true, value: void 0 };
+          const value = [ranges[idx * 2], ranges[idx * 2 + 1]];
+          ++idx;
+          return { done: false, value };
+        }
       };
+    }, ranges.length >>> 1);
+  }
+  Ranges2.intervalSequence = intervalSequence;
+  function sequence(ranges) {
+    let length = 0;
+    const leftsums = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      length += ranges[i + 1] - ranges[i] + 1;
+      leftsums.push(length);
     }
-    function createProxy(path9 = []) {
-      return new Proxy(() => {
-      }, {
-        get(target, prop) {
-          if (typeof prop === "symbol")
-            return void 0;
-          if (prop === "prepare")
-            return (input, options) => buildUrl(path9, input, options);
-          const newPath = [...path9, prop];
-          return createProxy(newPath);
-        },
-        apply(target, thisArg, args) {
-          const options = buildUrl(path9, args[0], args[1]);
-          return fetchCallback(options.url, {
-            method: options.method,
-            body: options.body,
-            headers: options.headers,
-            signal: options.signal
-          }).then(async (response) => {
-            if (response.status >= 200 && response.status < 300) {
-              if (response.headers.get("content-type")?.includes("application/json")) {
-                const text = await response.text();
-                return text.length ? JSON.parse(text) : void 0;
-              }
-              return await response.blob();
+    return new Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        const idx = Sequence.fromList(leftsums).partitionPoint((x) => x <= fromIdx);
+        const intervals = Ranges2.intervalSequence(ranges);
+        const it = intervals.seek(idx);
+        const firstInterval = it.next();
+        if (firstInterval.done)
+          return { next: () => firstInterval };
+        let from2 = firstInterval.value[0] + fromIdx - (idx > 0 ? leftsums[idx - 1] : 0);
+        let to = firstInterval.value[1];
+        return {
+          next() {
+            if (from2 > to) {
+              const interval = it.next();
+              if (interval.done)
+                return { done: true, value: void 0 };
+              from2 = interval.value[0];
+              to = interval.value[1];
             }
-            if (response.status >= 400 && response.status < 600) {
-              const text = await response.text();
-              if (text)
-                throw new Error(`HTTP request failed with status ${response.status}: ${text}`);
-              else
-                throw new Error(`HTTP request failed with status ${response.status}`);
-            }
-          });
-        }
-      });
-    }
-    return createProxy();
+            return { done: false, value: from2++ };
+          }
+        };
+      },
+      length
+    );
   }
-  TypedHTTP2.createClient = createClient;
-})(TypedHTTP || (TypedHTTP = {}));
+  Ranges2.sequence = sequence;
+})(Ranges || (Ranges = {}));
+
+// src/cli/cli.ts
+import { TypedHTTP as TypedHTTP4 } from "@flakiness/shared/common/typedHttp.js";
+import assert4 from "assert";
+import { Command, Option } from "commander";
+import fs12 from "fs";
+import path10 from "path";
+
+// src/flakinessConfig.ts
+import fs2 from "fs";
+import path2 from "path";
 
 // src/utils.ts
+import { FlakinessReport } from "@flakiness/report";
 import assert from "assert";
 import { spawnSync } from "child_process";
 import crypto from "crypto";
@@ -240,14 +753,7 @@ import fs from "fs";
 import http from "http";
 import https from "https";
 import os from "os";
-import { posix as posixPath, win32 as win32Path } from "path";
-import util from "util";
-import zlib from "zlib";
-var gzipAsync = util.promisify(zlib.gzip);
-var gunzipAsync = util.promisify(zlib.gunzip);
-var gunzipSync = zlib.gunzipSync;
-var brotliCompressAsync = util.promisify(zlib.brotliCompress);
-var brotliCompressSync = zlib.brotliCompressSync;
+import path, { posix as posixPath, win32 as win32Path } from "path";
 async function existsAsync(aPath) {
   return fs.promises.stat(aPath).then(() => true).catch((e) => false);
 }
@@ -272,6 +778,10 @@ function sha1File(filePath) {
     });
   });
 }
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
 function sha1Buffer(data) {
   const hash = crypto.createHash("sha1");
   hash.update(data);
@@ -283,9 +793,9 @@ async function retryWithBackoff(job, backoff = []) {
       return await job();
     } catch (e) {
       if (e instanceof AggregateError)
-        console.error(`[flakiness.io err]`, e.errors[0].message);
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
       else if (e instanceof Error)
-        console.error(`[flakiness.io err]`, e.message);
+        console.error(`[flakiness.io err]`, errorText(e));
       else
         console.error(`[flakiness.io err]`, e);
       await new Promise((x) => setTimeout(x, timeout));
@@ -303,6 +813,7 @@ var httpUtils;
       reject = b;
     });
     const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
     const request = protocol.request(url, { method, headers }, (res) => {
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
@@ -362,13 +873,11 @@ function shell(command, args, options) {
   try {
     const result = spawnSync(command, args, { encoding: "utf-8", ...options });
     if (result.status !== 0) {
-      console.log(result);
-      console.log(options);
       return void 0;
     }
     return result.stdout.trim();
   } catch (e) {
-    console.log(e);
+    console.error(e);
     return void 0;
   }
 }
@@ -424,6 +933,40 @@ function gitCommitInfo(gitRepo) {
   assert(sha, `FAILED: git rev-parse HEAD @ ${gitRepo}`);
   return sha.trim();
 }
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Set();
+  FlakinessReport.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.add(attachment.id);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
 function computeGitRoot(somePathInsideGitRepo) {
   const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
     cwd: somePathInsideGitRepo,
@@ -484,7 +1027,75 @@ function createEnvironments(projects) {
   return result;
 }
 
+// src/flakinessConfig.ts
+function createConfigPath(dir) {
+  return path2.join(dir, ".flakiness", "config.json");
+}
+var gConfigPath;
+function ensureConfigPath() {
+  if (!gConfigPath)
+    gConfigPath = computeConfigPath();
+  return gConfigPath;
+}
+function computeConfigPath() {
+  for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
+    const configPath = createConfigPath(p);
+    if (fs2.existsSync(configPath))
+      return configPath;
+  }
+  try {
+    const gitRoot = computeGitRoot(process.cwd());
+    return createConfigPath(gitRoot);
+  } catch (e) {
+    return createConfigPath(process.cwd());
+  }
+}
+var FlakinessConfig = class _FlakinessConfig {
+  constructor(_configPath, _config) {
+    this._configPath = _configPath;
+    this._config = _config;
+  }
+  static async load() {
+    const configPath = ensureConfigPath();
+    const data = await fs2.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const json = data ? JSON.parse(data) : {};
+    return new _FlakinessConfig(configPath, json);
+  }
+  static async projectOrDie(session2) {
+    const config = await _FlakinessConfig.load();
+    const projectPublicId = config.projectPublicId();
+    if (!projectPublicId)
+      throw new Error(`Please link to flakiness project with 'npx flakiness link'`);
+    const project = await session2.api.project.getProject.GET({ projectPublicId }).catch((e) => void 0);
+    if (!project)
+      throw new Error(`Failed to fetch linked project; please re-link with 'npx flakiness link'`);
+    return project;
+  }
+  static createEmpty() {
+    return new _FlakinessConfig(ensureConfigPath(), {});
+  }
+  path() {
+    return this._configPath;
+  }
+  projectPublicId() {
+    return this._config.projectPublicId;
+  }
+  setProjectPublicId(projectId) {
+    this._config.projectPublicId = projectId;
+  }
+  async save() {
+    await fs2.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
+    await fs2.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
+  }
+};
+
+// src/flakinessSession.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+
 // src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
 function createServerAPI(endpoint, options) {
   endpoint += "/api/";
   const fetcher = options?.auth ? (url, init) => fetch(url, {
@@ -501,24 +1112,30 @@ function createServerAPI(endpoint, options) {
 
 // src/flakinessSession.ts
 var CONFIG_DIR = (() => {
-  const configDir = process.platform === "darwin" ? path.join(os2.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path.join(os2.homedir(), "AppData", "Roaming", "flakiness") : path.join(os2.homedir(), ".config", "flakiness");
+  const configDir = process.platform === "darwin" ? path3.join(os2.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path3.join(os2.homedir(), "AppData", "Roaming", "flakiness") : path3.join(os2.homedir(), ".config", "flakiness");
   return configDir;
 })();
-var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var CONFIG_PATH = path3.join(CONFIG_DIR, "config.json");
 var FlakinessSession = class _FlakinessSession {
   constructor(_config) {
     this._config = _config;
     this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
   }
+  static async loadOrDie() {
+    const session2 = await _FlakinessSession.load();
+    if (!session2)
+      throw new Error(`Please login first with 'npx flakiness login'`);
+    return session2;
+  }
   static async load() {
-    const data = await fs2.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
+    const data = await fs3.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
     if (!data)
       return void 0;
     const json = JSON.parse(data);
     return new _FlakinessSession(json);
   }
   static async remove() {
-    await fs2.unlink(CONFIG_PATH).catch((e) => void 0);
+    await fs3.unlink(CONFIG_PATH).catch((e) => void 0);
   }
   api;
   endpoint() {
@@ -531,21 +1148,21 @@ var FlakinessSession = class _FlakinessSession {
     return this._config.token;
   }
   async save() {
-    await fs2.mkdir(CONFIG_DIR, { recursive: true });
-    await fs2.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+    await fs3.mkdir(CONFIG_DIR, { recursive: true });
+    await fs3.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
   }
 };
 
 // src/cli/cmd-convert.ts
-import fs4 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 
 // src/junit.ts
 import { FlakinessReport as FK } from "@flakiness/report";
 import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
 import assert2 from "assert";
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function getProperties(element) {
   const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
   if (!propertiesNodes.length)
@@ -587,8 +1204,8 @@ function extractStdout(testcase, stdio) {
   }));
 }
 async function parseAttachment(value) {
-  let absolutePath = path2.resolve(process.cwd(), value);
-  if (fs3.existsSync(absolutePath)) {
+  let absolutePath = path4.resolve(process.cwd(), value);
+  if (fs4.existsSync(absolutePath)) {
     const id = await sha1File(absolutePath);
     return {
       contentType: "image/png",
@@ -660,7 +1277,7 @@ async function traverseJUnitReport(context, node) {
           id: attachment.id,
           contentType: attachment.contentType,
           //TODO: better default names for attachments?
-          name: attachment.path ? path2.basename(attachment.path) : `attachment`
+          name: attachment.path ? path4.basename(attachment.path) : `attachment`
         });
       } else {
         annotations.push({
@@ -735,15 +1352,15 @@ async function parseJUnit(xmls, options) {
 
 // src/cli/cmd-convert.ts
 async function cmdConvert(junitPath, options) {
-  const fullPath = path3.resolve(junitPath);
-  if (!await fs4.access(fullPath, fs4.constants.F_OK).then(() => true).catch(() => false)) {
+  const fullPath = path5.resolve(junitPath);
+  if (!await fs5.access(fullPath, fs5.constants.F_OK).then(() => true).catch(() => false)) {
     console.error(`Error: path ${fullPath} is not accessible`);
     process.exit(1);
   }
-  const stat = await fs4.stat(fullPath);
+  const stat = await fs5.stat(fullPath);
   let xmlContents = [];
   if (stat.isFile()) {
-    const xmlContent = await fs4.readFile(fullPath, "utf-8");
+    const xmlContent = await fs5.readFile(fullPath, "utf-8");
     xmlContents.push(xmlContent);
   } else if (stat.isDirectory()) {
     const xmlFiles = await findXmlFiles(fullPath);
@@ -753,7 +1370,7 @@ async function cmdConvert(junitPath, options) {
     }
     console.log(`Found ${xmlFiles.length} XML files`);
     for (const xmlFile of xmlFiles) {
-      const xmlContent = await fs4.readFile(xmlFile, "utf-8");
+      const xmlContent = await fs5.readFile(xmlFile, "utf-8");
       xmlContents.push(xmlContent);
     }
   } else {
@@ -777,26 +1394,26 @@ async function cmdConvert(junitPath, options) {
     runStartTimestamp: Date.now(),
     runDuration: 0
   });
-  await fs4.writeFile("fkreport.json", JSON.stringify(report, null, 2));
+  await fs5.writeFile("fkreport.json", JSON.stringify(report, null, 2));
   console.log("\u2713 Saved report to fkreport.json");
   if (attachments.length > 0) {
-    await fs4.mkdir("fkattachments", { recursive: true });
+    await fs5.mkdir("fkattachments", { recursive: true });
     for (const attachment of attachments) {
       if (attachment.path) {
-        const destPath = path3.join("fkattachments", attachment.id);
-        await fs4.copyFile(attachment.path, destPath);
+        const destPath = path5.join("fkattachments", attachment.id);
+        await fs5.copyFile(attachment.path, destPath);
       } else if (attachment.body) {
-        const destPath = path3.join("fkattachments", attachment.id);
-        await fs4.writeFile(destPath, attachment.body);
+        const destPath = path5.join("fkattachments", attachment.id);
+        await fs5.writeFile(destPath, attachment.body);
       }
     }
     console.log(`\u2713 Saved ${attachments.length} attachments to fkattachments/`);
   }
 }
 async function findXmlFiles(dir, result = []) {
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path3.join(dir, entry.name);
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isFile() && entry.name.toLowerCase().endsWith(".xml"))
       result.push(fullPath);
     else if (entry.isDirectory())
@@ -807,53 +1424,8 @@ async function findXmlFiles(dir, result = []) {
 
 // src/cli/cmd-download.ts
 import fs6 from "fs";
-import path5 from "path";
-
-// src/flakinessLink.ts
-import fs5 from "fs/promises";
-import path4 from "path";
-var GIT_ROOT = computeGitRoot(process.cwd());
-var CONFIG_DIR2 = path4.join(GIT_ROOT, ".flakiness");
-var CONFIG_PATH2 = path4.join(CONFIG_DIR2, "config.json");
-var FlakinessLink = class _FlakinessLink {
-  constructor(_config) {
-    this._config = _config;
-  }
-  static async load() {
-    const data = await fs5.readFile(CONFIG_PATH2, "utf-8").catch((e) => void 0);
-    if (!data)
-      return void 0;
-    const json = JSON.parse(data);
-    return new _FlakinessLink(json);
-  }
-  static async remove() {
-    await fs5.unlink(CONFIG_PATH2).catch((e) => void 0);
-  }
-  path() {
-    return CONFIG_PATH2;
-  }
-  projectId() {
-    return this._config.projectId;
-  }
-  async save() {
-    await fs5.mkdir(CONFIG_DIR2, { recursive: true });
-    await fs5.writeFile(CONFIG_PATH2, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/cli/cmd-download.ts
-async function cmdDownload(runId) {
-  const session2 = await FlakinessSession.load();
-  if (!session2) {
-    console.log(`Please login first`);
-    process.exit(1);
-  }
-  const link = await FlakinessLink.load();
-  if (!link) {
-    console.log(`Please run 'npx flakiness link' to link to the project`);
-    process.exit(1);
-  }
-  const project = await session2.api.project.getProject.GET({ projectPublicId: link.projectId() });
+import path6 from "path";
+async function cmdDownload(session2, project, runId) {
   const urls = await session2.api.run.downloadURLs.GET({
     orgSlug: project.org.orgSlug,
     projectSlug: project.projectSlug,
@@ -864,7 +1436,7 @@ async function cmdDownload(runId) {
     console.log(`Directory ${rootDir} already exists!`);
     return;
   }
-  const attachmentsDir = path5.join(rootDir, "attachments");
+  const attachmentsDir = path6.join(rootDir, "attachments");
   await fs6.promises.mkdir(rootDir, { recursive: true });
   if (urls.attachmentURLs.length)
     await fs6.promises.mkdir(attachmentsDir, { recursive: true });
@@ -872,7 +1444,7 @@ async function cmdDownload(runId) {
   if (!response.ok)
     throw new Error(`HTTP error ${response.status} for report URL: ${urls.reportURL}`);
   const reportContent = await response.text();
-  await fs6.promises.writeFile(path5.join(rootDir, "report.json"), reportContent);
+  await fs6.promises.writeFile(path6.join(rootDir, "report.json"), reportContent);
   const attachmentDownloader = async () => {
     while (urls.attachmentURLs.length) {
       const url = urls.attachmentURLs.pop();
@@ -880,8 +1452,8 @@ async function cmdDownload(runId) {
       if (!response2.ok)
         throw new Error(`HTTP error ${response2.status} for attachment URL: ${url}`);
       const fileBuffer = Buffer.from(await response2.arrayBuffer());
-      const filename = path5.basename(new URL(url).pathname);
-      await fs6.promises.writeFile(path5.join(attachmentsDir, filename), fileBuffer);
+      const filename = path6.basename(new URL(url).pathname);
+      await fs6.promises.writeFile(path6.join(attachmentsDir, filename), fileBuffer);
     }
   };
   const workerPromises = [];
@@ -907,11 +1479,10 @@ async function cmdLink(slug) {
     console.log(`Failed to find project ${slug}`);
     process.exit(1);
   }
-  const link = new FlakinessLink({
-    projectId: project.projectPublicId
-  });
-  await link.save();
-  console.log(`\u2713 Link successful! Config saved to ${link.path()}`);
+  const config = FlakinessConfig.createEmpty();
+  config.setProjectPublicId(project.projectPublicId);
+  await config.save();
+  console.log(`\u2713 Linked to ${session2.endpoint()}/${project.org.orgSlug}/${project.projectSlug}`);
 }
 
 // ../server/lib/common/knownClientIds.js
@@ -921,6 +1492,7 @@ var KNOWN_CLIENT_IDS = {
 };
 
 // src/cli/cmd-login.ts
+import open from "open";
 import os3 from "os";
 async function cmdLogin(endpoint) {
   const api = createServerAPI(endpoint);
@@ -928,6 +1500,7 @@ async function cmdLogin(endpoint) {
     clientId: KNOWN_CLIENT_IDS.OFFICIAL_CLI,
     name: os3.hostname()
   });
+  await open(new URL(data.verificationUrl, endpoint).href);
   console.log(`Please navigate to ${new URL(data.verificationUrl, endpoint)}`);
   let token;
   while (Date.now() < data.deadline) {
@@ -949,15 +1522,226 @@ async function cmdLogin(endpoint) {
     endpoint,
     token
   });
-  await session2.save();
-  console.log(`\u2713 Login successful! Token saved to ${session2.path()}`);
+  try {
+    const user = await session2.api.user.whoami.GET();
+    await session2.save();
+    console.log(`\u2713 Logged in as ${user.userName} (${user.userLogin})`);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`x Failed to login:`, message);
+  }
 }
 
 // src/cli/cmd-logout.ts
 async function cmdLogout() {
+  const session2 = await FlakinessSession.load();
+  if (!session2)
+    return;
+  const currentSession = await session2.api.user.currentSession.GET().catch((e) => void 0);
+  if (currentSession)
+    await session2.api.user.logoutSession.POST({ sessionId: currentSession.sessionPublicId });
   await FlakinessSession.remove();
 }
 
+// src/cli/cmd-show-report.ts
+import chalk from "chalk";
+import open2 from "open";
+import path7 from "path";
+
+// src/localReportServer.ts
+import { TypedHTTP as TypedHTTP3 } from "@flakiness/shared/common/typedHttp.js";
+import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
+import { createTypedHttpExpressMiddleware } from "@flakiness/shared/node/typedHttpExpress.js";
+import bodyParser from "body-parser";
+import compression from "compression";
+import debug from "debug";
+import express from "express";
+import "express-async-errors";
+import fs8 from "fs";
+import http2 from "http";
+
+// src/localGit.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function listLocalCommits(gitRoot, head, count) {
+  const FIELD_SEPARATOR = "|~|";
+  const RECORD_SEPARATOR = "\0";
+  const prettyFormat = [
+    "%H",
+    // %H:  Full commit hash
+    "%at",
+    // %at: Author date as a Unix timestamp (seconds since epoch)
+    "%an",
+    // %an: Author name
+    "%s"
+    // %s:  Subject (the first line of the commit message)
+  ].join(FIELD_SEPARATOR);
+  const command = `git log ${head} -n ${count} --pretty=format:"${prettyFormat}" -z`;
+  try {
+    const { stdout } = await execAsync(command, { cwd: gitRoot });
+    if (!stdout) {
+      return [];
+    }
+    return stdout.trim().split(RECORD_SEPARATOR).filter((record) => record).map((record) => {
+      const [commitId, timestampStr, author, message] = record.split(FIELD_SEPARATOR);
+      return {
+        commitId,
+        timestamp: parseInt(timestampStr, 10) * 1e3,
+        // Convert timestamp from seconds to milliseconds
+        author,
+        message,
+        walkIndex: 0
+      };
+    });
+  } catch (error) {
+    console.error(`Failed to list commits for repository at ${gitRoot}:`, error);
+    throw error;
+  }
+}
+
+// src/localReportApi.ts
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
+import fs7 from "fs";
+import { z } from "zod/v4";
+var t = TypedHTTP2.Router.create();
+var localReportRouter = {
+  ping: t.get({
+    handler: async () => {
+      return "pong";
+    }
+  }),
+  lastCommits: t.get({
+    handler: async ({ ctx }) => {
+      return ctx.commits;
+    }
+  }),
+  report: {
+    attachment: t.rawMethod("GET", {
+      input: z.object({
+        attachmentId: z.string().min(1).max(100).transform((id) => id)
+      }),
+      handler: async ({ ctx, input }) => {
+        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        if (!idx)
+          throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
+        const buffer = await fs7.promises.readFile(idx.path);
+        return TypedHTTP2.ok(buffer, idx.contentType);
+      }
+    }),
+    json: t.get({
+      handler: async ({ ctx }) => {
+        return ctx.report;
+      }
+    })
+  }
+};
+
+// src/localReportServer.ts
+var logHTTPServer = debug("fk:http");
+var LocalReportServer = class _LocalReportServer {
+  constructor(_server, _port, _authToken) {
+    this._server = _server;
+    this._port = _port;
+    this._authToken = _authToken;
+  }
+  static async create(options) {
+    const app = express();
+    app.set("etag", false);
+    const authToken = randomUUIDBase62();
+    app.use(compression());
+    app.use(bodyParser.json({ limit: 256 * 1024 }));
+    app.use((req, res, next) => {
+      if (!req.path.startsWith("/" + authToken))
+        throw TypedHTTP3.HttpError.withCode("UNAUTHORIZED");
+      res.setHeader("Access-Control-Allow-Headers", "*");
+      res.setHeader("Access-Control-Allow-Origin", options.endpoint);
+      res.setHeader("Access-Control-Allow-Methods", "*");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      req.on("aborted", () => logHTTPServer(`REQ ABORTED ${req.method} ${req.originalUrl}`));
+      res.on("close", () => {
+        if (!res.headersSent)
+          logHTTPServer(`RES CLOSED BEFORE SEND ${req.method} ${req.originalUrl}`);
+      });
+      next();
+    });
+    app.use("/" + authToken, createTypedHttpExpressMiddleware({
+      router: localReportRouter,
+      createRootContext: async ({ req, res, input }) => {
+        const report = JSON.parse(await fs8.promises.readFile(options.reportPath, "utf-8"));
+        const attachmentsDir = options.attachmentsFolder;
+        const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
+        if (missingAttachments.length) {
+          const first = missingAttachments.slice(0, 3);
+          for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
+            console.warn(`Missing attachment with id ${missingAttachments[i]}`);
+          if (missingAttachments.length > 3)
+            console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
+        }
+        return {
+          report,
+          commits: await listLocalCommits(process.cwd(), report.commitId, 100),
+          attachmentIdToPath
+        };
+      }
+    }));
+    app.use((err, req, res, next) => {
+      if (err instanceof TypedHTTP3.HttpError)
+        return res.status(err.status).send({ error: err.message });
+      logHTTPServer(err);
+      res.status(500).send({ error: "Internal Server Error" });
+    });
+    const server = http2.createServer(app);
+    server.on("error", (err) => {
+      if (err.code === "ECONNRESET") {
+        logHTTPServer("Client connection reset. Ignoring.");
+        return;
+      }
+      throw err;
+    });
+    const port = await new Promise((resolve) => server.listen(options.port, () => {
+      resolve(server.address().port);
+    }));
+    return new _LocalReportServer(server, port, authToken);
+  }
+  authToken() {
+    return this._authToken;
+  }
+  port() {
+    return this._port;
+  }
+  async dispose() {
+    await new Promise((x) => this._server.close(x));
+  }
+};
+
+// src/cli/cmd-show-report.ts
+async function cmdShowReport(reportFolder) {
+  const reportPath = path7.join(reportFolder, "report.json");
+  const session2 = await FlakinessSession.load();
+  const config = await FlakinessConfig.load();
+  const projectPublicId = config.projectPublicId();
+  const project = projectPublicId && session2 ? await session2.api.project.getProject.GET({ projectPublicId }) : void 0;
+  const endpoint = session2?.endpoint() ?? "https://flakiness.io";
+  const server = await LocalReportServer.create({
+    endpoint,
+    port: 9373,
+    reportPath,
+    attachmentsFolder: reportFolder
+  });
+  const reportEndpoint = project ? `${endpoint}/localreport/${project.org.orgSlug}/${project.projectSlug}?port=${server.port()}&token=${server.authToken()}` : `${endpoint}/localreport?port=${server.port()}&token=${server.authToken()}`;
+  console.log(chalk.cyan(`
+  Serving Flakiness report at ${reportEndpoint}
+  Press Ctrl+C to quit.`));
+  await open2(reportEndpoint);
+  await new Promise(() => {
+  });
+}
+
 // src/cli/cmd-status.ts
 async function cmdStatus() {
   const session2 = await FlakinessSession.load();
@@ -967,31 +1751,34 @@ async function cmdStatus() {
   }
   const user = await session2.api.user.whoami.GET();
   console.log(`user: ${user.userName} (${user.userLogin})`);
-  const link = await FlakinessLink.load();
-  if (!link) {
+  const config = await FlakinessConfig.load();
+  const projectPublicId = config.projectPublicId();
+  if (!projectPublicId) {
     console.log(`project: <not linked>`);
     return;
   }
-  const project = await session2.api.project.getProject.GET({
-    projectPublicId: link.projectId()
-  });
+  const project = await session2.api.project.getProject.GET({ projectPublicId });
   console.log(`project: ${session2.endpoint()}/${project.org.orgSlug}/${project.projectSlug}`);
 }
 
 // src/cli/cmd-unlink.ts
 async function cmdUnlink() {
-  await FlakinessLink.remove();
+  const config = await FlakinessConfig.load();
+  if (!config.projectPublicId())
+    return;
+  config.setProjectPublicId(void 0);
+  await config.save();
 }
 
 // src/cli/cmd-upload-playwright-json.ts
-import fs8 from "fs/promises";
-import path6 from "path";
+import fs10 from "fs/promises";
+import path8 from "path";
 
 // src/playwrightJSONReport.ts
-import { FlakinessReport as FK2, FlakinessReport } from "@flakiness/report";
-import debug from "debug";
+import { FlakinessReport as FK2, FlakinessReport as FlakinessReport2 } from "@flakiness/report";
+import debug2 from "debug";
 import { posix as posixPath2 } from "path";
-var dlog = debug("flakiness:json-report");
+var dlog = debug2("flakiness:json-report");
 var PlaywrightJSONReport;
 ((PlaywrightJSONReport2) => {
   function collectMetadata(somePathInsideProject = process.cwd()) {
@@ -1023,7 +1810,7 @@ var PlaywrightJSONReport;
     };
     const configPath = jsonReport.config.configFile ? gitFilePath(context.gitRoot, normalizePath(jsonReport.config.configFile)) : void 0;
     const report = {
-      category: FlakinessReport.CATEGORY_PLAYWRIGHT,
+      category: FlakinessReport2.CATEGORY_PLAYWRIGHT,
       commitId: metadata.commitId,
       configPath,
       url: metadata.runURL,
@@ -1163,9 +1950,10 @@ function parseJSONError(context, error) {
 }
 
 // src/reportUploader.ts
-import fs7 from "fs";
+import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
+import assert3 from "assert";
+import fs9 from "fs";
 import { URL as URL2 } from "url";
-import { brotliCompressSync as brotliCompressSync2 } from "zlib";
 var ReportUploader = class _ReportUploader {
   static optionsFromEnv(overrides) {
     const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
@@ -1177,7 +1965,8 @@ var ReportUploader = class _ReportUploader {
   static async upload(options) {
     const uploaderOptions = _ReportUploader.optionsFromEnv(options);
     if (!uploaderOptions) {
-      options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
+      if (process.env.CI)
+        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
       return void 0;
     }
     const uploader = new _ReportUploader(uploaderOptions);
@@ -1210,11 +1999,10 @@ var ReportUpload = class {
     this._options = options;
     this._report = report;
     this._attachments = attachments;
-    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF });
+    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF, auth: this._options.flakinessAccessToken });
   }
   async upload(options) {
     const response = await this._api.run.startUpload.POST({
-      flakinessAccessToken: this._options.flakinessAccessToken,
       attachmentIds: this._attachments.map((attachment) => attachment.id)
     }).then((result) => ({ result, error: void 0 })).catch((e) => ({ result: void 0, error: e }));
     if (response?.error || !response.result)
@@ -1225,7 +2013,7 @@ var ReportUpload = class {
         const uploadURL = response.result.attachment_upload_urls[attachment.id];
         if (!uploadURL)
           throw new Error("Internal error: missing upload URL for attachment!");
-        return this._uploadAttachment(attachment, uploadURL);
+        return this._uploadAttachment(attachment, uploadURL, options?.syncCompression ?? false);
       })
     ]);
     const response2 = await this._api.run.completeUpload.POST({
@@ -1235,7 +2023,7 @@ var ReportUpload = class {
     return { success: true, reportUrl: url };
   }
   async _uploadReport(data, uploadUrl, syncCompression) {
-    const compressed = syncCompression ? brotliCompressSync2(data) : await brotliCompressAsync(data);
+    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
     const headers = {
       "Content-Type": "application/json",
       "Content-Length": Buffer.byteLength(compressed) + "",
@@ -1252,11 +2040,34 @@ var ReportUpload = class {
       await responseDataPromise;
     }, HTTP_BACKOFF);
   }
-  async _uploadAttachment(attachment, uploadUrl) {
-    const bytesLength = attachment.path ? (await fs7.promises.stat(attachment.path)).size : attachment.body ? Buffer.byteLength(attachment.body) : 0;
+  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
+    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
+    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
+    if (!compressable && attachment.path) {
+      const attachmentPath = attachment.path;
+      await retryWithBackoff(async () => {
+        const { request, responseDataPromise } = httpUtils.createRequest({
+          url: uploadUrl,
+          headers: {
+            "Content-Type": attachment.contentType,
+            "Content-Length": (await fs9.promises.stat(attachmentPath)).size + ""
+          },
+          method: "put"
+        });
+        fs9.createReadStream(attachmentPath).pipe(request);
+        await responseDataPromise;
+      }, HTTP_BACKOFF);
+      return;
+    }
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs9.promises.readFile(attachment.path) : void 0;
+    assert3(buffer);
+    const encoding = compressable ? "br" : void 0;
+    if (compressable)
+      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
     const headers = {
       "Content-Type": attachment.contentType,
-      "Content-Length": bytesLength + ""
+      "Content-Length": Buffer.byteLength(buffer) + "",
+      "Content-Encoding": encoding
     };
     await retryWithBackoff(async () => {
       const { request, responseDataPromise } = httpUtils.createRequest({
@@ -1264,13 +2075,8 @@ var ReportUpload = class {
         headers,
         method: "put"
       });
-      if (attachment.path) {
-        fs7.createReadStream(attachment.path).pipe(request);
-      } else {
-        if (attachment.body)
-          request.write(attachment.body);
-        request.end();
-      }
+      request.write(buffer);
+      request.end();
       await responseDataPromise;
     }, HTTP_BACKOFF);
   }
@@ -1278,12 +2084,12 @@ var ReportUpload = class {
 
 // src/cli/cmd-upload-playwright-json.ts
 async function cmdUploadPlaywrightJson(relativePath, options) {
-  const fullPath = path6.resolve(relativePath);
-  if (!await fs8.access(fullPath, fs8.constants.F_OK).then(() => true).catch(() => false)) {
+  const fullPath = path8.resolve(relativePath);
+  if (!await fs10.access(fullPath, fs10.constants.F_OK).then(() => true).catch(() => false)) {
     console.error(`Error: path ${fullPath} is not accessible`);
     process.exit(1);
   }
-  const text = await fs8.readFile(fullPath, "utf-8");
+  const text = await fs10.readFile(fullPath, "utf-8");
   const playwrightJson = JSON.parse(text);
   const { attachments, report, unaccessibleAttachmentPaths } = await PlaywrightJSONReport.parse(PlaywrightJSONReport.collectMetadata(), playwrightJson, {
     extractAttachments: true
@@ -1304,38 +2110,18 @@ async function cmdUploadPlaywrightJson(relativePath, options) {
 }
 
 // src/cli/cmd-upload.ts
-import { FlakinessReport as FlakinessReport2 } from "@flakiness/report";
-import fs9 from "fs/promises";
-import path7 from "path";
+import fs11 from "fs/promises";
+import path9 from "path";
 async function cmdUpload(relativePath, options) {
-  const fullPath = path7.resolve(relativePath);
-  if (!await fs9.access(fullPath, fs9.constants.F_OK).then(() => true).catch(() => false)) {
+  const fullPath = path9.resolve(relativePath);
+  if (!await fs11.access(fullPath, fs11.constants.F_OK).then(() => true).catch(() => false)) {
     console.error(`Error: path ${fullPath} is not accessible`);
     process.exit(1);
   }
-  const attachmentsDir = options.attachmentsDir ?? path7.dirname(fullPath);
-  const attachmentFiles = await listFilesRecursively(attachmentsDir);
-  const attachmentIdToPath = new Map(attachmentFiles.map((file) => [path7.basename(file), file]));
-  const text = await fs9.readFile(fullPath, "utf-8");
+  const text = await fs11.readFile(fullPath, "utf-8");
   const report = JSON.parse(text);
-  const attachments = [];
-  const missingAttachments = [];
-  FlakinessReport2.visitTests(report, (test) => {
-    for (const attempt of test.attempts) {
-      for (const attachment of attempt.attachments ?? []) {
-        const file = attachmentIdToPath.get(attachment.id);
-        if (!file) {
-          missingAttachments.push(attachment);
-          continue;
-        }
-        attachments.push({
-          contentType: attachment.contentType,
-          id: attachment.id,
-          path: file
-        });
-      }
-    }
-  });
+  const attachmentsDir = options.attachmentsDir ?? path9.dirname(fullPath);
+  const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
   if (missingAttachments.length && !options.ignoreMissingAttachments) {
     console.log(`Missing ${missingAttachments.length} attachments - exiting. Use --ignore-missing-attachments to force upload.`);
     process.exit(1);
@@ -1344,7 +2130,7 @@ async function cmdUpload(relativePath, options) {
     flakinessAccessToken: options.accessToken,
     flakinessEndpoint: options.endpoint
   });
-  const upload = uploader.createUpload(report, attachments);
+  const upload = uploader.createUpload(report, Array.from(attachmentIdToPath.values()));
   const uploadResult = await upload.upload();
   if (!uploadResult.success) {
     console.log(`[flakiness.io] X Failed to upload to ${options.endpoint}: ${uploadResult.message}`);
@@ -1352,17 +2138,6 @@ async function cmdUpload(relativePath, options) {
     console.log(`[flakiness.io] \u2713 Report uploaded ${uploadResult.reportUrl ?? uploadResult.message ?? ""}`);
   }
 }
-async function listFilesRecursively(dir, result = []) {
-  const entries = await fs9.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path7.join(dir, entry.name);
-    if (entry.isDirectory())
-      await listFilesRecursively(fullPath, result);
-    else
-      result.push(fullPath);
-  }
-  return result;
-}
 
 // src/cli/cmd-whoami.ts
 async function cmdWhoami() {
@@ -1378,7 +2153,7 @@ async function cmdWhoami() {
 
 // src/cli/cli.ts
 var session = await FlakinessSession.load();
-var optAccessToken = new Option("-t, --access-token <token>", "A read-write flakiness.io access token").makeOptionMandatory().env("FLAKINESS_ACCESS_TOKEN");
+var optAccessToken = new Option("-t, --access-token <token>", "A read-write flakiness.io access token").env("FLAKINESS_ACCESS_TOKEN");
 var optEndpoint = new Option("-e, --endpoint <url>", "An endpoint where the service is deployed").default(session?.endpoint() ?? "https://flakiness.io").env("FLAKINESS_ENDPOINT");
 var optAttachmentsDir = new Option("--attachments-dir <dir>", "Directory containing attachments to upload. Defaults to the report directory");
 var optIgnoreMissingAttachments = new Option("--ignore-missing-attachments", "Upload report even if some attachments are missing.").default("", "Same directory as the report file");
@@ -1388,20 +2163,42 @@ async function runCommand(callback) {
   } catch (e) {
     if (!(e instanceof Error))
       throw e;
-    if (process.env.DBG)
-      console.error(e.stack);
-    else
-      console.error(e.message);
+    console.error(errorText(e));
     process.exit(1);
   }
 }
-var PACKAGE_JSON = JSON.parse(fs10.readFileSync(path8.resolve(import.meta.dirname, "..", "..", "package.json"), "utf-8"));
+var PACKAGE_JSON = JSON.parse(fs12.readFileSync(path10.resolve(import.meta.dirname, "..", "..", "package.json"), "utf-8"));
 var program = new Command().name("flakiness").description("Flakiness CLI tool").version(PACKAGE_JSON.version);
+async function ensureAccessToken(options) {
+  let accessToken = options.accessToken;
+  if (!accessToken) {
+    const config = await FlakinessConfig.load();
+    const projectPublicId = config.projectPublicId();
+    if (session && projectPublicId) {
+      try {
+        accessToken = (await session.api.project.getProject.GET({ projectPublicId })).readWriteAccessToken;
+      } catch (e) {
+        if (e instanceof TypedHTTP4.HttpError && e.status === 404) {
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  assert4(accessToken, `Please either pass FLAKINESS_ACCESS_TOKEN or run login + link`);
+  return {
+    ...options,
+    accessToken
+  };
+}
 program.command("upload-playwright-json", { hidden: true }).description("Upload Playwright Test JSON report to the flakiness.io service").argument("<relative-path-to-json>", "Path to the Playwright JSON report file").addOption(optAccessToken).addOption(optEndpoint).action(async (relativePath, options) => runCommand(async () => {
-  await cmdUploadPlaywrightJson(relativePath, options);
+  await cmdUploadPlaywrightJson(relativePath, await ensureAccessToken(options));
 }));
-program.command("login").description("Login to the flakiness.io service").addOption(optEndpoint).action(async (options) => runCommand(async () => {
+var optLink = new Option("--link <org/proj>", "A project to link to");
+program.command("login").description("Login to the flakiness.io service").addOption(optEndpoint).addOption(optLink).action(async (options) => runCommand(async () => {
   await cmdLogin(options.endpoint);
+  if (options.link)
+    await cmdLink(options.link);
 }));
 program.command("logout").description("Logout from current session").action(async () => runCommand(async () => {
   await cmdLogout();
@@ -1418,14 +2215,60 @@ program.command("unlink").description("Unlink repository from the flakiness proj
 program.command("status").description("Status repository from the flakiness project").action(async () => runCommand(async () => {
   await cmdStatus();
 }));
-program.command("download").description("Download run").argument("runId", "Run id to download").action(async (runId) => runCommand(async () => {
-  await cmdDownload(parseInt(runId, 10));
+var optRunId = new Option("--run-id <runId>", "RunId flakiness.io access token").argParser((value) => {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < 1) {
+    throw new Error("runId must be a number >= 1");
+  }
+  return parsed;
+});
+var optSince = new Option("--since <date>", "Start date for filtering").argParser((value) => {
+  const parsed = new Date(value);
+  if (isNaN(parsed.getTime())) {
+    throw new Error("Invalid date format");
+  }
+  return parsed;
+});
+var optParallel = new Option("-j, --parallel <date>", "Parallel jobs to run").argParser((value) => {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < 1) {
+    throw new Error("parallel must be a number >= 1");
+  }
+  return parsed;
+});
+program.command("download").description("Download run").addOption(optSince).addOption(optRunId).addOption(optParallel).action(async (options) => runCommand(async () => {
+  const session2 = await FlakinessSession.loadOrDie();
+  const project = await FlakinessConfig.projectOrDie(session2);
+  let runIds = [];
+  if (options.runId) {
+    runIds = [options.runId, options.runId];
+  } else if (options.since) {
+    runIds = await session2.api.project.listRuns.GET({
+      orgSlug: project.org.orgSlug,
+      projectSlug: project.projectSlug,
+      sinceTimestampMs: +options.since
+    });
+    console.log(`Found ${Ranges.cardinality(runIds)} reports uploaded since ${options.since}`);
+  }
+  const it = Ranges.iterate(runIds);
+  const downloaders = [];
+  for (let i = 0; i < (options.parallel ?? 1); ++i) {
+    downloaders.push((async () => {
+      for (let result = it.next(); !result.done; result = it.next())
+        await cmdDownload(session2, project, result.value);
+    })());
+  }
+  await Promise.all(downloaders);
 }));
 program.command("upload").description("Upload Flakiness report to the flakiness.io service").argument("<relative-path>", "Path to the Flakiness report file").addOption(optAccessToken).addOption(optEndpoint).addOption(optAttachmentsDir).addOption(optIgnoreMissingAttachments).action(async (relativePath, options) => {
   await runCommand(async () => {
-    await cmdUpload(relativePath, options);
+    await cmdUpload(relativePath, await ensureAccessToken(options));
   });
 });
+program.command("show-report [report]").description("Show flakiness report").argument("[relative-path]", "Path to the Flakiness report file or folder that contains `report.json`.").action(async (arg) => runCommand(async () => {
+  const dir = path10.join(process.cwd(), arg ?? "flakiness-report");
+  await cmdShowReport(dir);
+}));
 program.command("convert-junit").description("Convert JUnit XML report(s) to Flakiness report format").argument("<junit-root-dir-path>", "Path to JUnit XML file or directory containing XML files").option("--env-name <name>", "Environment name for the report", "default").option("--commit-id <id>", "Git commit ID (auto-detected if not provided)").action(async (junitPath, options) => {
   await runCommand(async () => {
     await cmdConvert(junitPath, options);