@codesandbox/sdk/dist/esm/browser.js

The CodeSandbox SDK

if (typeof window !== "undefined" && !window.process) {
window.process = {
  env: {},
};
}


// src/utils/event.ts
var Emitter = class {
  constructor() {
    this.registeredListeners = /* @__PURE__ */ new Set();
  }
  get event() {
    if (!this._event) {
      this._event = (listener) => {
        this.registeredListeners.add(listener);
        return Disposable.create(() => {
          this.registeredListeners.delete(listener);
        });
      };
    }
    return this._event;
  }
  /** Invoke all listeners registered to this event. */
  fire(event) {
    this.registeredListeners.forEach((listener) => {
      listener(event);
    });
  }
  dispose() {
    this.registeredListeners = /* @__PURE__ */ new Set();
  }
};
var EmitterSubscription = class {
  constructor(createSubscription) {
    this.createSubscription = createSubscription;
    this.emitter = new Emitter();
    this.listenerCount = 0;
  }
  get event() {
    return (listener) => {
      const listenerDisposable = this.emitter.event(listener);
      if (this.listenerCount === 0) {
        this.subscription = this.createSubscription(
          (value) => this.emitter.fire(value)
        );
      }
      this.listenerCount++;
      return Disposable.create(() => {
        listenerDisposable.dispose();
        this.listenerCount--;
        if (this.listenerCount === 0 && this.subscription) {
          this.subscription.dispose();
          this.subscription = void 0;
        }
      });
    };
  }
  dispose() {
    this.subscription?.dispose();
    this.subscription = void 0;
    this.emitter.dispose();
    this.listenerCount = 0;
  }
};

// src/utils/disposable.ts
var Disposable = class _Disposable {
  constructor() {
    this.onWillDisposeEmitter = new Emitter();
    this.onWillDispose = this.onWillDisposeEmitter.event;
    this.onDidDisposeEmitter = new Emitter();
    this.onDidDispose = this.onDidDisposeEmitter.event;
    this.toDispose = [];
    this.isDisposed = false;
  }
  addDisposable(disposable) {
    this.toDispose.push(disposable);
    return disposable;
  }
  onDispose(cb) {
    this.toDispose.push(_Disposable.create(cb));
  }
  dispose() {
    if (this.isDisposed) return;
    this.onWillDisposeEmitter.fire(null);
    this.isDisposed = true;
    this.toDispose.forEach((disposable) => {
      disposable.dispose();
    });
    this.onDidDisposeEmitter.fire(null);
    this.onWillDisposeEmitter.dispose();
    this.onDidDisposeEmitter.dispose();
  }
  static is(arg) {
    return typeof arg === "object" && arg !== null && "dispose" in arg && typeof arg.dispose === "function";
  }
  static create(cb) {
    return {
      dispose: cb
    };
  }
};
var DisposableStore = class _DisposableStore {
  constructor() {
    this._toDispose = /* @__PURE__ */ new Set();
    this._isDisposed = false;
  }
  static {
    this.DISABLE_DISPOSED_WARNING = true;
  }
  /**
   * Dispose of all registered disposables and mark this object as disposed.
   *
   * Any future disposables added to this object will be disposed of on `add`.
   */
  dispose() {
    if (this._isDisposed) {
      return;
    }
    this._isDisposed = true;
    this.clear();
  }
  /**
   * Dispose of all registered disposables but do not mark this object as disposed.
   */
  clear() {
    try {
      for (const disposable of this._toDispose.values()) {
        disposable.dispose();
      }
    } finally {
      this._toDispose.clear();
    }
  }
  add(o) {
    if (!o) {
      return o;
    }
    if (o === this) {
      throw new Error("Cannot register a disposable on itself!");
    }
    if (this._isDisposed) {
      if (!_DisposableStore.DISABLE_DISPOSED_WARNING) {
        console.warn(
          new Error(
            "Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!"
          ).stack
        );
      }
    } else {
      this._toDispose.add(o);
    }
    return o;
  }
};

// src/api-clients/client/core/params.gen.ts
var extraPrefixesMap = {
  $body_: "body",
  $headers_: "headers",
  $path_: "path",
  $query_: "query"
};
var extraPrefixes = Object.entries(extraPrefixesMap);

// src/api-clients/client/core/pathSerializer.gen.ts
var separatorArrayExplode = (style) => {
  switch (style) {
    case "label":
      return ".";
    case "matrix":
      return ";";
    case "simple":
      return ",";
    default:
      return "&";
  }
};
var separatorArrayNoExplode = (style) => {
  switch (style) {
    case "form":
      return ",";
    case "pipeDelimited":
      return "|";
    case "spaceDelimited":
      return "%20";
    default:
      return ",";
  }
};
var separatorObjectExplode = (style) => {
  switch (style) {
    case "label":
      return ".";
    case "matrix":
      return ";";
    case "simple":
      return ",";
    default:
      return "&";
  }
};
var serializeArrayParam = ({
  allowReserved,
  explode,
  name,
  style,
  value
}) => {
  if (!explode) {
    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
    switch (style) {
      case "label":
        return `.${joinedValues2}`;
      case "matrix":
        return `;${name}=${joinedValues2}`;
      case "simple":
        return joinedValues2;
      default:
        return `${name}=${joinedValues2}`;
    }
  }
  const separator = separatorArrayExplode(style);
  const joinedValues = value.map((v) => {
    if (style === "label" || style === "simple") {
      return allowReserved ? v : encodeURIComponent(v);
    }
    return serializePrimitiveParam({
      allowReserved,
      name,
      value: v
    });
  }).join(separator);
  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
};
var serializePrimitiveParam = ({
  allowReserved,
  name,
  value
}) => {
  if (value === void 0 || value === null) {
    return "";
  }
  if (typeof value === "object") {
    throw new Error(
      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
    );
  }
  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
};
var serializeObjectParam = ({
  allowReserved,
  explode,
  name,
  style,
  value,
  valueOnly
}) => {
  if (value instanceof Date) {
    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
  }
  if (style !== "deepObject" && !explode) {
    let values = [];
    Object.entries(value).forEach(([key, v]) => {
      values = [
        ...values,
        key,
        allowReserved ? v : encodeURIComponent(v)
      ];
    });
    const joinedValues2 = values.join(",");
    switch (style) {
      case "form":
        return `${name}=${joinedValues2}`;
      case "label":
        return `.${joinedValues2}`;
      case "matrix":
        return `;${name}=${joinedValues2}`;
      default:
        return joinedValues2;
    }
  }
  const separator = separatorObjectExplode(style);
  const joinedValues = Object.entries(value).map(
    ([key, v]) => serializePrimitiveParam({
      allowReserved,
      name: style === "deepObject" ? `${name}[${key}]` : key,
      value: v
    })
  ).join(separator);
  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
};

// src/api-clients/client/client/utils.gen.ts
var createQuerySerializer = ({
  allowReserved,
  array,
  object
} = {}) => {
  const querySerializer = (queryParams) => {
    const search = [];
    if (queryParams && typeof queryParams === "object") {
      for (const name in queryParams) {
        const value = queryParams[name];
        if (value === void 0 || value === null) {
          continue;
        }
        if (Array.isArray(value)) {
          const serializedArray = serializeArrayParam({
            allowReserved,
            explode: true,
            name,
            style: "form",
            value,
            ...array
          });
          if (serializedArray) search.push(serializedArray);
        } else if (typeof value === "object") {
          const serializedObject = serializeObjectParam({
            allowReserved,
            explode: true,
            name,
            style: "deepObject",
            value,
            ...object
          });
          if (serializedObject) search.push(serializedObject);
        } else {
          const serializedPrimitive = serializePrimitiveParam({
            allowReserved,
            name,
            value
          });
          if (serializedPrimitive) search.push(serializedPrimitive);
        }
      }
    }
    return search.join("&");
  };
  return querySerializer;
};
var defaultQuerySerializer = createQuerySerializer({
  allowReserved: false,
  array: {
    explode: true,
    style: "form"
  },
  object: {
    explode: true,
    style: "deepObject"
  }
});

// src/utils/api.ts
async function retryWithDelay(callback, retries = 3, delay = 500) {
  let lastError;
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      return await callback();
    } catch (error) {
      lastError = error;
      if (attempt === retries) {
        throw lastError;
      }
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
  throw lastError;
}

// node_modules/@opentelemetry/api/build/esm/trace/status.js
var SpanStatusCode;
(function(SpanStatusCode2) {
  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
})(SpanStatusCode || (SpanStatusCode = {}));

// node_modules/fflate/esm/browser.js
var ch2 = {};
var wk = function(c, id, msg, transfer, cb) {
  var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([
    c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'
  ], { type: "text/javascript" }))));
  w.onmessage = function(e) {
    var d = e.data, ed = d.$e$;
    if (ed) {
      var err2 = new Error(ed[0]);
      err2["code"] = ed[1];
      err2.stack = ed[2];
      cb(err2, null);
    } else
      cb(null, d);
  };
  w.postMessage(msg, transfer);
  return w;
};
var u8 = Uint8Array;
var u16 = Uint16Array;
var i32 = Int32Array;
var fleb = new u8([
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  1,
  1,
  1,
  1,
  2,
  2,
  2,
  2,
  3,
  3,
  3,
  3,
  4,
  4,
  4,
  4,
  5,
  5,
  5,
  5,
  0,
  /* unused */
  0,
  0,
  /* impossible */
  0
]);
var fdeb = new u8([
  0,
  0,
  0,
  0,
  1,
  1,
  2,
  2,
  3,
  3,
  4,
  4,
  5,
  5,
  6,
  6,
  7,
  7,
  8,
  8,
  9,
  9,
  10,
  10,
  11,
  11,
  12,
  12,
  13,
  13,
  /* unused */
  0,
  0
]);
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
var freb = function(eb, start) {
  var b = new u16(31);
  for (var i = 0; i < 31; ++i) {
    b[i] = start += 1 << eb[i - 1];
  }
  var r = new i32(b[30]);
  for (var i = 1; i < 30; ++i) {
    for (var j = b[i]; j < b[i + 1]; ++j) {
      r[j] = j - b[i] << 5 | i;
    }
  }
  return { b, r };
};
var _a = freb(fleb, 2);
var fl = _a.b;
var revfl = _a.r;
fl[28] = 258, revfl[258] = 28;
var _b = freb(fdeb, 0);
var fd = _b.b;
var revfd = _b.r;
var rev = new u16(32768);
for (i = 0; i < 32768; ++i) {
  x = (i & 43690) >> 1 | (i & 21845) << 1;
  x = (x & 52428) >> 2 | (x & 13107) << 2;
  x = (x & 61680) >> 4 | (x & 3855) << 4;
  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
}
var x;
var i;
var hMap = function(cd, mb, r) {
  var s = cd.length;
  var i = 0;
  var l = new u16(mb);
  for (; i < s; ++i) {
    if (cd[i])
      ++l[cd[i] - 1];
  }
  var le = new u16(mb);
  for (i = 1; i < mb; ++i) {
    le[i] = le[i - 1] + l[i - 1] << 1;
  }
  var co;
  if (r) {
    co = new u16(1 << mb);
    var rvb = 15 - mb;
    for (i = 0; i < s; ++i) {
      if (cd[i]) {
        var sv = i << 4 | cd[i];
        var r_1 = mb - cd[i];
        var v = le[cd[i] - 1]++ << r_1;
        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
          co[rev[v] >> rvb] = sv;
        }
      }
    }
  } else {
    co = new u16(s);
    for (i = 0; i < s; ++i) {
      if (cd[i]) {
        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
      }
    }
  }
  return co;
};
var flt = new u8(288);
for (i = 0; i < 144; ++i)
  flt[i] = 8;
var i;
for (i = 144; i < 256; ++i)
  flt[i] = 9;
var i;
for (i = 256; i < 280; ++i)
  flt[i] = 7;
var i;
for (i = 280; i < 288; ++i)
  flt[i] = 8;
var i;
var fdt = new u8(32);
for (i = 0; i < 32; ++i)
  fdt[i] = 5;
var i;
var flm = /* @__PURE__ */ hMap(flt, 9, 0);
var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
var shft = function(p) {
  return (p + 7) / 8 | 0;
};
var slc = function(v, s, e) {
  if (s == null || s < 0)
    s = 0;
  if (e == null || e > v.length)
    e = v.length;
  return new u8(v.subarray(s, e));
};
var ec = [
  "unexpected EOF",
  "invalid block type",
  "invalid length/literal",
  "invalid distance",
  "stream finished",
  "no stream handler",
  ,
  "no callback",
  "invalid UTF-8 data",
  "extra field too long",
  "date not in range 1980-2099",
  "filename too long",
  "stream finishing",
  "invalid zip data"
  // determined by unknown compression method
];
var err = function(ind, msg, nt) {
  var e = new Error(msg || ec[ind]);
  e.code = ind;
  if (Error.captureStackTrace)
    Error.captureStackTrace(e, err);
  if (!nt)
    throw e;
  return e;
};
var wbits = function(d, p, v) {
  v <<= p & 7;
  var o = p / 8 | 0;
  d[o] |= v;
  d[o + 1] |= v >> 8;
};
var wbits16 = function(d, p, v) {
  v <<= p & 7;
  var o = p / 8 | 0;
  d[o] |= v;
  d[o + 1] |= v >> 8;
  d[o + 2] |= v >> 16;
};
var hTree = function(d, mb) {
  var t = [];
  for (var i = 0; i < d.length; ++i) {
    if (d[i])
      t.push({ s: i, f: d[i] });
  }
  var s = t.length;
  var t2 = t.slice();
  if (!s)
    return { t: et, l: 0 };
  if (s == 1) {
    var v = new u8(t[0].s + 1);
    v[t[0].s] = 1;
    return { t: v, l: 1 };
  }
  t.sort(function(a, b) {
    return a.f - b.f;
  });
  t.push({ s: -1, f: 25001 });
  var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
  t[0] = { s: -1, f: l.f + r.f, l, r };
  while (i1 != s - 1) {
    l = t[t[i0].f < t[i2].f ? i0++ : i2++];
    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
    t[i1++] = { s: -1, f: l.f + r.f, l, r };
  }
  var maxSym = t2[0].s;
  for (var i = 1; i < s; ++i) {
    if (t2[i].s > maxSym)
      maxSym = t2[i].s;
  }
  var tr = new u16(maxSym + 1);
  var mbt = ln(t[i1 - 1], tr, 0);
  if (mbt > mb) {
    var i = 0, dt = 0;
    var lft = mbt - mb, cst = 1 << lft;
    t2.sort(function(a, b) {
      return tr[b.s] - tr[a.s] || a.f - b.f;
    });
    for (; i < s; ++i) {
      var i2_1 = t2[i].s;
      if (tr[i2_1] > mb) {
        dt += cst - (1 << mbt - tr[i2_1]);
        tr[i2_1] = mb;
      } else
        break;
    }
    dt >>= lft;
    while (dt > 0) {
      var i2_2 = t2[i].s;
      if (tr[i2_2] < mb)
        dt -= 1 << mb - tr[i2_2]++ - 1;
      else
        ++i;
    }
    for (; i >= 0 && dt; --i) {
      var i2_3 = t2[i].s;
      if (tr[i2_3] == mb) {
        --tr[i2_3];
        ++dt;
      }
    }
    mbt = mb;
  }
  return { t: new u8(tr), l: mbt };
};
var ln = function(n, l, d) {
  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
};
var lc = function(c) {
  var s = c.length;
  while (s && !c[--s])
    ;
  var cl = new u16(++s);
  var cli = 0, cln = c[0], cls = 1;
  var w = function(v) {
    cl[cli++] = v;
  };
  for (var i = 1; i <= s; ++i) {
    if (c[i] == cln && i != s)
      ++cls;
    else {
      if (!cln && cls > 2) {
        for (; cls > 138; cls -= 138)
          w(32754);
        if (cls > 2) {
          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
          cls = 0;
        }
      } else if (cls > 3) {
        w(cln), --cls;
        for (; cls > 6; cls -= 6)
          w(8304);
        if (cls > 2)
          w(cls - 3 << 5 | 8208), cls = 0;
      }
      while (cls--)
        w(cln);
      cls = 1;
      cln = c[i];
    }
  }
  return { c: cl.subarray(0, cli), n: s };
};
var clen = function(cf, cl) {
  var l = 0;
  for (var i = 0; i < cl.length; ++i)
    l += cf[i] * cl[i];
  return l;
};
var wfblk = function(out, pos, dat) {
  var s = dat.length;
  var o = shft(pos + 2);
  out[o] = s & 255;
  out[o + 1] = s >> 8;
  out[o + 2] = out[o] ^ 255;
  out[o + 3] = out[o + 1] ^ 255;
  for (var i = 0; i < s; ++i)
    out[o + i + 4] = dat[i];
  return (o + 4 + s) * 8;
};
var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
  wbits(out, p++, final);
  ++lf[256];
  var _a3 = hTree(lf, 15), dlt = _a3.t, mlb = _a3.l;
  var _b3 = hTree(df, 15), ddt = _b3.t, mdb = _b3.l;
  var _c2 = lc(dlt), lclt = _c2.c, nlc = _c2.n;
  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
  var lcfreq = new u16(19);
  for (var i = 0; i < lclt.length; ++i)
    ++lcfreq[lclt[i] & 31];
  for (var i = 0; i < lcdt.length; ++i)
    ++lcfreq[lcdt[i] & 31];
  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
  var nlcc = 19;
  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
    ;
  var flen = bl + 5 << 3;
  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
    return wfblk(out, p, dat.subarray(bs, bs + bl));
  var lm, ll, dm, dl;
  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
  if (dtlen < ftlen) {
    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
    var llm = hMap(lct, mlcb, 0);
    wbits(out, p, nlc - 257);
    wbits(out, p + 5, ndc - 1);
    wbits(out, p + 10, nlcc - 4);
    p += 14;
    for (var i = 0; i < nlcc; ++i)
      wbits(out, p + 3 * i, lct[clim[i]]);
    p += 3 * nlcc;
    var lcts = [lclt, lcdt];
    for (var it = 0; it < 2; ++it) {
      var clct = lcts[it];
      for (var i = 0; i < clct.length; ++i) {
        var len = clct[i] & 31;
        wbits(out, p, llm[len]), p += lct[len];
        if (len > 15)
          wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
      }
    }
  } else {
    lm = flm, ll = flt, dm = fdm, dl = fdt;
  }
  for (var i = 0; i < li; ++i) {
    var sym = syms[i];
    if (sym > 255) {
      var len = sym >> 18 & 31;
      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
      if (len > 7)
        wbits(out, p, sym >> 23 & 31), p += fleb[len];
      var dst = sym & 31;
      wbits16(out, p, dm[dst]), p += dl[dst];
      if (dst > 3)
        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
    } else {
      wbits16(out, p, lm[sym]), p += ll[sym];
    }
  }
  wbits16(out, p, lm[256]);
  return p + ll[256];
};
var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
var et = /* @__PURE__ */ new u8(0);
var dflt = function(dat, lvl, plvl, pre, post, st) {
  var s = st.z || dat.length;
  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
  var w = o.subarray(pre, o.length - post);
  var lst = st.l;
  var pos = (st.r || 0) & 7;
  if (lvl) {
    if (pos)
      w[0] = st.r >> 3;
    var opt = deo[lvl - 1];
    var n = opt >> 13, c = opt & 8191;
    var msk_1 = (1 << plvl) - 1;
    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
    var hsh = function(i2) {
      return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
    };
    var syms = new i32(25e3);
    var lf = new u16(288), df = new u16(32);
    var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
    for (; i + 2 < s; ++i) {
      var hv = hsh(i);
      var imod = i & 32767, pimod = head[hv];
      prev[imod] = pimod;
      head[hv] = imod;
      if (wi <= i) {
        var rem = s - i;
        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
          li = lc_1 = eb = 0, bs = i;
          for (var j = 0; j < 286; ++j)
            lf[j] = 0;
          for (var j = 0; j < 30; ++j)
            df[j] = 0;
        }
        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
        if (rem > 2 && hv == hsh(i - dif)) {
          var maxn = Math.min(n, rem) - 1;
          var maxd = Math.min(32767, i);
          var ml = Math.min(258, rem);
          while (dif <= maxd && --ch_1 && imod != pimod) {
            if (dat[i + l] == dat[i + l - dif]) {
              var nl = 0;
              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
                ;
              if (nl > l) {
                l = nl, d = dif;
                if (nl > maxn)
                  break;
                var mmd = Math.min(dif, nl - 2);
                var md = 0;
                for (var j = 0; j < mmd; ++j) {
                  var ti = i - dif + j & 32767;
                  var pti = prev[ti];
                  var cd = ti - pti & 32767;
                  if (cd > md)
                    md = cd, pimod = ti;
                }
              }
            }
            imod = pimod, pimod = prev[imod];
            dif += imod - pimod & 32767;
          }
        }
        if (d) {
          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
          var lin = revfl[l] & 31, din = revfd[d] & 31;
          eb += fleb[lin] + fdeb[din];
          ++lf[257 + lin];
          ++df[din];
          wi = i + l;
          ++lc_1;
        } else {
          syms[li++] = dat[i];
          ++lf[dat[i]];
        }
      }
    }
    for (i = Math.max(i, wi); i < s; ++i) {
      syms[li++] = dat[i];
      ++lf[dat[i]];
    }
    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
    if (!lst) {
      st.r = pos & 7 | w[pos / 8 | 0] << 3;
      pos -= 7;
      st.h = head, st.p = prev, st.i = i, st.w = wi;
    }
  } else {
    for (var i = st.w || 0; i < s + lst; i += 65535) {
      var e = i + 65535;
      if (e >= s) {
        w[pos / 8 | 0] = lst;
        e = s;
      }
      pos = wfblk(w, pos + 1, dat.subarray(i, e));
    }
    st.i = s;
  }
  return slc(o, 0, pre + shft(pos) + post);
};
var crct = /* @__PURE__ */ function() {
  var t = new Int32Array(256);
  for (var i = 0; i < 256; ++i) {
    var c = i, k = 9;
    while (--k)
      c = (c & 1 && -306674912) ^ c >>> 1;
    t[i] = c;
  }
  return t;
}();
var crc = function() {
  var c = -1;
  return {
    p: function(d) {
      var cr = c;
      for (var i = 0; i < d.length; ++i)
        cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
      c = cr;
    },
    d: function() {
      return ~c;
    }
  };
};
var dopt = function(dat, opt, pre, post, st) {
  if (!st) {
    st = { l: 1 };
    if (opt.dictionary) {
      var dict = opt.dictionary.subarray(-32768);
      var newDat = new u8(dict.length + dat.length);
      newDat.set(dict);
      newDat.set(dat, dict.length);
      dat = newDat;
      st.w = dict.length;
    }
  }
  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
};
var mrg = function(a, b) {
  var o = {};
  for (var k in a)
    o[k] = a[k];
  for (var k in b)
    o[k] = b[k];
  return o;
};
var wcln = function(fn, fnStr, td2) {
  var dt = fn();
  var st = fn.toString();
  var ks = st.slice(st.indexOf("[") + 1, st.lastIndexOf("]")).replace(/\s+/g, "").split(",");
  for (var i = 0; i < dt.length; ++i) {
    var v = dt[i], k = ks[i];
    if (typeof v == "function") {
      fnStr += ";" + k + "=";
      var st_1 = v.toString();
      if (v.prototype) {
        if (st_1.indexOf("[native code]") != -1) {
          var spInd = st_1.indexOf(" ", 8) + 1;
          fnStr += st_1.slice(spInd, st_1.indexOf("(", spInd));
        } else {
          fnStr += st_1;
          for (var t in v.prototype)
            fnStr += ";" + k + ".prototype." + t + "=" + v.prototype[t].toString();
        }
      } else
        fnStr += st_1;
    } else
      td2[k] = v;
  }
  return fnStr;
};
var ch = [];
var cbfs = function(v) {
  var tl = [];
  for (var k in v) {
    if (v[k].buffer) {
      tl.push((v[k] = new v[k].constructor(v[k])).buffer);
    }
  }
  return tl;
};
var wrkr = function(fns, init, id, cb) {
  if (!ch[id]) {
    var fnStr = "", td_1 = {}, m = fns.length - 1;
    for (var i = 0; i < m; ++i)
      fnStr = wcln(fns[i], fnStr, td_1);
    ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
  }
  var td2 = mrg({}, ch[id].e);
  return wk(ch[id].c + ";onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=" + init.toString() + "}", id, td2, cbfs(td2), cb);
};
var bDflt = function() {
  return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf];
};
var pbf = function(msg) {
  return postMessage(msg, [msg.buffer]);
};
var cbify = function(dat, opts, fns, init, id, cb) {
  var w = wrkr(fns, init, id, function(err2, dat2) {
    w.terminate();
    cb(err2, dat2);
  });
  w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);
  return function() {
    w.terminate();
  };
};
var wbytes = function(d, b, v) {
  for (; v; ++b)
    d[b] = v, v >>>= 8;
};
function deflate(data, opts, cb) {
  if (!cb)
    cb = opts, opts = {};
  if (typeof cb != "function")
    err(7);
  return cbify(data, opts, [
    bDflt
  ], function(ev) {
    return pbf(deflateSync(ev.data[0], ev.data[1]));
  }, 0, cb);
}
function deflateSync(data, opts) {
  return dopt(data, opts || {}, 0, 0);
}
var fltn = function(d, p, t, o) {
  for (var k in d) {
    var val = d[k], n = p + k, op = o;
    if (Array.isArray(val))
      op = mrg(o, val[1]), val = val[0];
    if (val instanceof u8)
      t[n] = [val, op];
    else {
      t[n += "/"] = [new u8(0), op];
      fltn(val, n, t, o);
    }
  }
};
var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
var tds = 0;
try {
  td.decode(et, { stream: true });
  tds = 1;
} catch (e) {
}
function strToU8(str, latin1) {
  if (latin1) {
    var ar_1 = new u8(str.length);
    for (var i = 0; i < str.length; ++i)
      ar_1[i] = str.charCodeAt(i);
    return ar_1;
  }
  if (te)
    return te.encode(str);
  var l = str.length;
  var ar = new u8(str.length + (str.length >> 1));
  var ai = 0;
  var w = function(v) {
    ar[ai++] = v;
  };
  for (var i = 0; i < l; ++i) {
    if (ai + 5 > ar.length) {
      var n = new u8(ai + 8 + (l - i << 1));
      n.set(ar);
      ar = n;
    }
    var c = str.charCodeAt(i);
    if (c < 128 || latin1)
      w(c);
    else if (c < 2048)
      w(192 | c >> 6), w(128 | c & 63);
    else if (c > 55295 && c < 57344)
      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
    else
      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
  }
  return slc(ar, 0, ai);
}
var exfl = function(ex) {
  var le = 0;
  if (ex) {
    for (var k in ex) {
      var l = ex[k].length;
      if (l > 65535)
        err(9);
      le += l + 4;
    }
  }
  return le;
};
var wzh = function(d, b, f, fn, u, c, ce, co) {
  var fl2 = fn.length, ex = f.extra, col = co && co.length;
  var exl = exfl(ex);
  wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
  if (ce != null)
    d[b++] = 20, d[b++] = f.os;
  d[b] = 20, b += 2;
  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
  var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
  if (y < 0 || y > 119)
    err(10);
  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
  if (c != -1) {
    wbytes(d, b, f.crc);
    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
    wbytes(d, b + 8, f.size);
  }
  wbytes(d, b + 12, fl2);
  wbytes(d, b + 14, exl), b += 16;
  if (ce != null) {
    wbytes(d, b, col);
    wbytes(d, b + 6, f.attrs);
    wbytes(d, b + 10, ce), b += 14;
  }
  d.set(fn, b);
  b += fl2;
  if (exl) {
    for (var k in ex) {
      var exf = ex[k], l = exf.length;
      wbytes(d, b, +k);
      wbytes(d, b + 2, l);
      d.set(exf, b + 4), b += 4 + l;
    }
  }
  if (col)
    d.set(co, b), b += col;
  return b;
};
var wzf = function(o, b, c, d, e) {
  wbytes(o, b, 101010256);
  wbytes(o, b + 8, c);
  wbytes(o, b + 10, c);
  wbytes(o, b + 12, d);
  wbytes(o, b + 16, e);
};
function zip(data, opts, cb) {
  if (!cb)
    cb = opts, opts = {};
  if (typeof cb != "function")
    err(7);
  var r = {};
  fltn(data, "", r, opts);
  var k = Object.keys(r);
  var lft = k.length, o = 0, tot = 0;
  var slft = lft, files = new Array(lft);
  var term = [];
  var tAll = function() {
    for (var i2 = 0; i2 < term.length; ++i2)
      term[i2]();
  };
  var cbd = function(a, b) {
    mt(function() {
      cb(a, b);
    });
  };
  mt(function() {
    cbd = cb;
  });
  var cbf = function() {
    var out = new u8(tot + 22), oe = o, cdl = tot - o;
    tot = 0;
    for (var i2 = 0; i2 < slft; ++i2) {
      var f = files[i2];
      try {
        var l = f.c.length;
        wzh(out, tot, f, f.f, f.u, l);
        var badd = 30 + f.f.length + exfl(f.extra);
        var loc = tot + badd;
        out.set(f.c, loc);
        wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;
      } catch (e) {
        return cbd(e, null);
      }
    }
    wzf(out, o, files.length, cdl, oe);
    cbd(null, out);
  };
  if (!lft)
    cbf();
  var _loop_1 = function(i2) {
    var fn = k[i2];
    var _a3 = r[fn], file = _a3[0], p = _a3[1];
    var c = crc(), size = file.length;
    c.p(file);
    var f = strToU8(fn), s = f.length;
    var com = p.comment, m = com && strToU8(com), ms = m && m.length;
    var exl = exfl(p.extra);
    var compression = p.level == 0 ? 0 : 8;
    var cbl = function(e, d) {
      if (e) {
        tAll();
        cbd(e, null);
      } else {
        var l = d.length;
        files[i2] = mrg(p, {
          size,
          crc: c.d(),
          c: d,
          f,
          m,
          u: s != fn.length || m && com.length != ms,
          compression
        });
        o += 30 + s + exl + l;
        tot += 76 + 2 * (s + exl) + (ms || 0) + l;
        if (!--lft)
          cbf();
      }
    };
    if (s > 65535)
      cbl(err(11, 0, 1), null);
    if (!compression)
      cbl(null, file);
    else if (size < 16e4) {
      try {
        cbl(null, deflateSync(file, p));
      } catch (e) {
        cbl(e, null);
      }
    } else
      term.push(deflate(file, p, cbl));
  };
  for (var i = 0; i < slft; ++i) {
    _loop_1(i);
  }
  return tAll;
}
var mt = typeof queueMicrotask == "function" ? queueMicrotask : typeof setTimeout == "function" ? setTimeout : function(fn) {
  fn();
};

// src/SandboxClient/filesystem.ts
var FileSystem = class {
  constructor(sessionDisposable, agentClient, username, tracer) {
    this.agentClient = agentClient;
    this.username = username;
    this.disposable = new Disposable();
    this.tracer = tracer;
    sessionDisposable.onWillDispose(() => {
      this.disposable.dispose();
    });
  }
  async withSpan(operationName, attributes = {}, operation) {
    if (!this.tracer) {
      return operation();
    }
    return this.tracer.startActiveSpan(
      operationName,
      { attributes },
      async (span) => {
        try {
          const result = await operation();
          span.setStatus({ code: SpanStatusCode.OK });
          return result;
        } catch (error) {
          span.setStatus({
            code: SpanStatusCode.ERROR,
            message: error instanceof Error ? error.message : String(error)
          });
          span.recordException(
            error instanceof Error ? error : new Error(String(error))
          );
          throw error;
        } finally {
          span.end();
        }
      }
    );
  }
  /**
   * Write a file.
   */
  async writeFile(path, content, opts = {}) {
    return this.withSpan(
      "fs.writeFile",
      {
        "fs.path": path,
        "fs.size": content.length,
        "fs.create": opts.create ?? true,
        "fs.overwrite": opts.overwrite ?? true
      },
      async () => {
        const result = await this.agentClient.fs.writeFile(
          path,
          content,
          opts.create ?? true,
          opts.overwrite ?? true
        );
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
      }
    );
  }
  /**
   * Write a file as a string.
   */
  async writeTextFile(path, content, opts = {}) {
    return this.withSpan(
      "fs.writeTextFile",
      {
        "fs.path": path,
        "fs.contentLength": content.length,
        "fs.create": opts.create ?? true,
        "fs.overwrite": opts.overwrite ?? true
      },
      async () => {
        return this.writeFile(path, new TextEncoder().encode(content), opts);
      }
    );
  }
  /**
   * Batch write multiple files by zipping them, uploading the zip, and extracting it on the sandbox.
   * This is more efficient than writing many files individually.
   * Files will be created/overwritten as needed.
   */
  async batchWrite(files) {
    return this.withSpan(
      "fs.batchWrite",
      {
        "fs.fileCount": files.length
      },
      async () => {
        if (files.length === 0) {
          return;
        }
        const zipData = {};
        for (const file of files) {
          const content = typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
          zipData[file.path] = content;
        }
        const zipBytes = await new Promise((resolve, reject) => {
          zip(zipData, (err2, data) => {
            if (err2) reject(err2);
            else resolve(data);
          });
        });
        const tempZipPath = `/tmp/batch_write_${Date.now()}.zip`;
        await this.writeFile(tempZipPath, zipBytes);
        try {
          const result = await this.agentClient.shells.create(
            this.agentClient.workspacePath,
            { cols: 128, rows: 24 },
            `cd ${this.agentClient.workspacePath} && unzip -o ${tempZipPath}`,
            "COMMAND",
            true
          );
          if (result.status === "ERROR" || result.status === "KILLED") {
            throw new Error(
              `Failed to extract batch files: ${result.buffer?.join("\n") || "Unknown error"}`
            );
          }
          if (result.status === "RUNNING") {
            await new Promise((resolve, reject) => {
              const disposable = this.agentClient.shells.onShellExited(
                ({ shellId, exitCode }) => {
                  if (shellId === result.shellId) {
                    disposable.dispose();
                    if (exitCode === 0) {
                      resolve();
                    } else {
                      reject(
                        new Error(
                          `Unzip command failed with exit code ${exitCode}`
                        )
                      );
                    }
                  }
                }
              );
            });
          }
        } finally {
          try {
            await this.remove(tempZipPath);
          } catch {
          }
        }
      }
    );
  }
  /**
   * Create a directory.
   */
  async mkdir(path, recursive = false) {
    return this.withSpan(
      "fs.mkdir",
      {
        "fs.path": path,
        "fs.recursive": recursive
      },
      async () => {
        const result = await this.agentClient.fs.mkdir(path, recursive);
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
      }
    );
  }
  /**
   * Read a directory.
   */
  async readdir(path) {
    return this.withSpan("fs.readdir", { "fs.path": path }, async () => {
      const result = await this.agentClient.fs.readdir(path);
      if (result.type === "error") {
        throw new Error(`${result.errno}: ${result.error}`);
      }
      return result.result.entries.map((entry) => ({
        ...entry,
        type: entry.type === 0 ? "file" : "directory"
      }));
    });
  }
  /**
   * Read a file
   */
  async readFile(path) {
    return this.withSpan("fs.readFile", { "fs.path": path }, async () => {
      const result = await this.agentClient.fs.readFile(path);
      if (result.type === "error") {
        throw new Error(`${result.errno}: ${result.error}`);
      }
      return result.result.content;
    });
  }
  /**
   * Read a file as a string.
   */
  async readTextFile(path) {
    return this.withSpan("fs.readTextFile", { "fs.path": path }, async () => {
      const content = await this.readFile(path);
      return new TextDecoder("utf-8").decode(content);
    });
  }
  /**
   * Get the stat of a file or directory.
   */
  async stat(path) {
    return this.withSpan("fs.stat", { "fs.path": path }, async () => {
      const result = await this.agentClient.fs.stat(path);
      if (result.type === "error") {
        throw new Error(`${result.errno}: ${result.error}`);
      }
      return {
        ...result.result,
        type: result.result.type === 0 ? "file" : "directory"
      };
    });
  }
  /**
   * Copy a file or directory.
   */
  async copy(from, to, recursive = false, overwrite = false) {
    return this.withSpan(
      "fs.copy",
      {
        "fs.from": from,
        "fs.to": to,
        "fs.recursive": recursive,
        "fs.overwrite": overwrite
      },
      async () => {
        const result = await this.agentClient.fs.copy(
          from,
          to,
          recursive,
          overwrite
        );
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
      }
    );
  }
  /**
   * Rename a file or directory.
   */
  async rename(from, to, overwrite = false) {
    return this.withSpan(
      "fs.rename",
      {
        "fs.from": from,
        "fs.to": to,
        "fs.overwrite": overwrite
      },
      async () => {
        const result = await this.agentClient.fs.rename(from, to, overwrite);
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
      }
    );
  }
  /**
   * Remove a file or directory.
   */
  async remove(path, recursive = false) {
    return this.withSpan(
      "fs.remove",
      {
        "fs.path": path,
        "fs.recursive": recursive
      },
      async () => {
        const result = await this.agentClient.fs.remove(path, recursive);
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
      }
    );
  }
  /**
   * Watch for changes in the filesystem.
   *
   * ```ts
   * const watcher = await sandbox.fs.watch("/path/to/watch");
   * watcher.onEvent((event) => {
   *   console.log(event);
   * });
   *
   * // When done
   * watcher.dispose();
   * ```
   *
   * @param path - The path to watch.
   * @param options - The options for the watch.
   * @returns A watcher that can be disposed to stop the watch.
   */
  async watch(path, options = {}) {
    return this.withSpan(
      "fs.watch",
      {
        "fs.path": path,
        "fs.recursive": options.recursive ?? false,
        "fs.excludeCount": options.excludes?.length ?? 0
      },
      async () => {
        const emitter = new Emitter();
        const result = await this.agentClient.fs.watch(
          path,
          options,
          (event) => {
            if (this.username) {
              emitter.fire({
                ...event,
                paths: event.paths.map(
                  (path2) => path2.replace(`home/${this.username}/workspace/`, "sandbox/")
                )
              });
            } else {
              emitter.fire(event);
            }
          }
        );
        if (result.type === "error") {
          throw new Error(`${result.errno}: ${result.error}`);
        }
        const watcher = {
          dispose: () => {
            result.dispose();
            emitter.dispose();
          },
          onEvent: emitter.event
        };
        this.disposable.addDisposable(watcher);
        return watcher;
      }
    );
  }
  /**
   * Download a file or folder from the filesystem, can only be used to download
   * from within the workspace directory. A download URL that's valid for 5 minutes.
   */
  async download(path) {
    return this.withSpan("fs.download", { "fs.path": path }, async () => {
      const result = await this.agentClient.fs.download(path);
      return result;
    });
  }
};

// src/SandboxClient/ports.ts
var Ports = class {
  constructor(sessionDisposable, agentClient, tracer) {
    this.agentClient = agentClient;
    this.tracer = tracer;
    this.disposable = new Disposable();
    this.onDidPortOpenEmitter = this.disposable.addDisposable(
      new Emitter()
    );
    this.onDidPortCloseEmitter = this.disposable.addDisposable(
      new Emitter()
    );
    this.lastOpenedPorts = /* @__PURE__ */ new Set();
    sessionDisposable.onWillDispose(() => {
      this.disposable.dispose();
    });
    agentClient.ports.getPorts().then((ports) => {
      ports.forEach((port2) => {
        this.lastOpenedPorts.add(port2.port);
      });
    });
    this.disposable.addDisposable(
      agentClient.ports.onPortsUpdated((ports) => {
        const openedPorts = ports.filter(
          (port2) => !this.lastOpenedPorts.has(port2.port)
        );
        const closedPorts = [...this.lastOpenedPorts].filter(
          (port2) => !ports.some((p) => p.port === port2)
        );
        if (openedPorts.length) {
          for (const port2 of openedPorts) {
            this.onDidPortOpenEmitter.fire({
              port: port2.port,
              host: port2.url
            });
          }
        }
        if (closedPorts.length) {
          for (const port2 of closedPorts) {
            this.onDidPortCloseEmitter.fire(port2);
          }
        }
        this.lastOpenedPorts = new Set(ports.map((port2) => port2.port));
      })
    );
  }
  get onDidPortOpen() {
    return this.onDidPortOpenEmitter.event;
  }
  get onDidPortClose() {
    return this.onDidPortCloseEmitter.event;
  }
  withSpan(operationName, attributes, fn) {
    if (!this.tracer) {
      return fn();
    }
    return this.tracer.startActiveSpan(
      operationName,
      { attributes },
      async (span) => {
        try {
          const result = await fn();
          span.setStatus({ code: SpanStatusCode.OK });
          return result;
        } catch (error) {
          span.setStatus({
            code: SpanStatusCode.ERROR,
            message: error instanceof Error ? error.message : String(error)
          });
          span.recordException(
            error instanceof Error ? error : new Error(String(error))
          );
          throw error;
        } finally {
          span.end();
        }
      }
    );
  }
  /**
   * Get a port by number.
   */
  async get(port2) {
    return this.withSpan("ports.get", { "port.number": port2 }, async () => {
      const ports = await this.getAll();
      return ports.find((p) => p.port === port2);
    });
  }
  /**
   * Get all ports.
   */
  async getAll() {
    return this.withSpan("ports.getAll", {}, async () => {
      const ports = await this.agentClient.ports.getPorts();
      return ports.map(({ port: port2, url }) => ({ port: port2, host: url }));
    });
  }
  /**
   * Wait for a port to be opened.
   *
   * @param port - The port to wait for.
   * @param options - Additional options
   * @param options.timeoutMs - Optional timeout in milliseconds. If specified, the promise will reject after this time if the port hasn't opened.
   * @returns A promise that resolves when the port is opened.
   * @throws {Error} If the timeout is reached before the port opens
   */
  async waitForPort(port2, options) {
    return this.withSpan(
      "ports.waitForPort",
      {
        "port.number": port2,
        "port.timeout.ms": options?.timeoutMs
      },
      async () => {
        return new Promise(async (resolve, reject) => {
          const portInfo = (await this.getAll()).find((p) => p.port === port2);
          if (portInfo) {
            resolve(portInfo);
            return;
          }
          let timeoutId;
          if (options?.timeoutMs !== void 0) {
            timeoutId = setTimeout(() => {
              reject(
                new Error(
                  `Timeout of ${options.timeoutMs}ms exceeded waiting for port ${port2} to open`
                )
              );
            }, options.timeoutMs);
          }
          const disposable = this.disposable.addDisposable(
            this.onDidPortOpen((portInfo2) => {
              if (portInfo2.port === port2) {
                if (timeoutId !== void 0) {
                  clearTimeout(timeoutId);
                }
                resolve(portInfo2);
                disposable.dispose();
              }
            })
          );
        });
      }
    );
  }
};

// src/utils/barrier.ts
var Barrier = class {
  constructor() {
    this._isOpen = false;
    this._promise = new Promise((resolve) => {
      this._completePromise = resolve;
    });
  }
  /**
   * Returns true if the barrier is open, false if it is closed
   * @returns true if the barrier is open, false if it is closed
   */
  isOpen() {
    return this._isOpen;
  }
  /**
   * Opens the barrier. If the barrier is already open, this method does nothing.
   * @param value the value to return when the barrier is opened
   * @returns
   */
  open(value) {
    if (this._isOpen) {
      return;
    }
    this._isOpen = true;
    this._completePromise({ status: "resolved", value });
  }
  /**
   *
   * @returns a promise that resolves when the barrier is opened. If the barrier is already open, the promise resolves immediately.
   */
  wait() {
    return this._promise;
  }
  /**
   * DO NOT USE THIS METHOD in production code. This is only for tests.
   * This is a convenience method that waits for the barrier to open and then returns the value.
   * If the Barrier is disposed while waiting to open, an error is thrown.
   * @returns the value if the barrier is open, otherwise throws an error
   */
  async __waitAndThrowIfDisposed() {
    const r = await this.wait();
    if (r.status === "disposed") {
      throw new Error("Barrier was disposed");
    }
    return r.value;
  }
  /**
   * Disposes the barrier.
   * If there is a promise waiting for the barrier to open, it will be resolved with a status of "disposed".
   */
  dispose() {
    this._completePromise({ status: "disposed" });
  }
};

// src/SandboxClient/commands.ts
var CommandError = class _CommandError extends Error {
  constructor(message, exitCode, output) {
    super(message);
    this.name = "CommandError";
    this.exitCode = exitCode;
    this.output = output;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, _CommandError);
    }
  }
};
var DEFAULT_SHELL_SIZE = { cols: 128, rows: 24 };
var SandboxCommands = class {
  constructor(sessionDisposable, agentClient, tracer) {
    this.agentClient = agentClient;
    this.disposable = new Disposable();
    this.tracer = tracer;
    sessionDisposable.onWillDispose(() => {
      this.disposable.dispose();
    });
  }
  async withSpan(operationName, attributes = {}, operation) {
    if (!this.tracer) {
      return operation();
    }
    return this.tracer.startActiveSpan(
      operationName,
      { attributes },
      async (span) => {
        try {
          const result = await operation();
          span.setStatus({ code: SpanStatusCode.OK });
          return result;
        } catch (error) {
          span.setStatus({
            code: SpanStatusCode.ERROR,
            message: error instanceof Error ? error.message : String(error)
          });
          span.recordException(
            error instanceof Error ? error : new Error(String(error))
          );
          throw error;
        } finally {
          span.end();
        }
      }
    );
  }
  /**
   * Create and run command in a new shell. Allows you to listen to the output and kill the command.
   */
  async runBackground(command, opts) {
    const cmdString = Array.isArray(command) ? command.join(" && ") : command;
    return this.withSpan(
      "commands.runBackground",
      {
        "command.text": cmdString,
        "command.cwd": opts?.cwd || "/project",
        "command.asGlobalSession": opts?.asGlobalSession || false,
        "command.name": opts?.name || ""
      },
      async () => {
        const disposableStore = new DisposableStore();
        const onOutput = new Emitter();
        disposableStore.add(onOutput);
        command = Array.isArray(command) ? command.join(" && ") : command;
        const passedEnv = Object.assign(opts?.env ?? {});
        const escapedCommand = command.replace(/'/g, "'\\''");
        let commandWithEnv = Object.keys(passedEnv).length ? `source $HOME/.private/.env 2>/dev/null || true && env ${Object.entries(
          passedEnv
        ).map(([key, value]) => {
          const escapedValue = String(value).replace(/'/g, "'\\''");
          return `${key}='${escapedValue}'`;
        }).join(" ")} bash -c '${escapedCommand}'` : `source $HOME/.private/.env 2>/dev/null || true && bash -c '${escapedCommand}'`;
        if (opts?.cwd) {
          commandWithEnv = `cd ${opts.cwd} && ${commandWithEnv}`;
        }
        const shell2 = await this.agentClient.shells.create(
          this.agentClient.workspacePath,
          opts?.dimensions ?? DEFAULT_SHELL_SIZE,
          commandWithEnv,
          opts?.asGlobalSession ? "COMMAND" : "TERMINAL",
          true
        );
        if (shell2.status === "ERROR" || shell2.status === "KILLED") {
          throw new Error(`Failed to create shell: ${shell2.buffer.join("\n")}`);
        }
        const details = {
          type: "command",
          command,