@swmansion/argent 0.13.0 → 0.13.1-next.0

package/dist/mcp-server.mjs

@@ -3648,49 +3648,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        relative = parse3(serialize(relative, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative.scheme) {
+        target.scheme = relative.scheme;
+        target.userinfo = relative.userinfo;
+        target.host = relative.host;
+        target.port = relative.port;
+        target.path = removeDotSegments(relative.path || "");
+        target.query = relative.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+          target.userinfo = relative.userinfo;
+          target.host = relative.host;
+          target.port = relative.port;
+          target.path = removeDotSegments(relative.path || "");
+          target.query = relative.query;
         } else {
-          if (!relative2.path) {
+          if (!relative.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative.query !== void 0) {
+              target.query = relative.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative.path[0] === "/") {
+              target.path = removeDotSegments(relative.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3698,7 +3698,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -6891,7 +6891,7 @@ var require_dist = __commonJS({
 
 // ../argent-mcp/src/mcp-server.ts
 import { appendFile, mkdir as mkdir5 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
@@ -15460,12 +15460,13 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
-import { spawn } from "node:child_process";
+import { spawn, execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
+var LOCK_FILE = path.join(STATE_DIR, "tool-server.lock");
 var AUTH_TOKEN_BYTES = 32;
 var AUTH_TOKEN_ENV = "ARGENT_AUTH_TOKEN";
 var AUTOSPAWN_IDLE_TIMEOUT_MINUTES = 30;
@@ -15532,6 +15533,8 @@ async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, t
       signal: controller.signal,
       headers: authHeaders(token)
     });
+    await res.body?.cancel().catch(() => {
+    });
     return res.ok;
   } catch {
     return false;
@@ -15539,6 +15542,17 @@ async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, t
     clearTimeout(timer);
   }
 }
+var SPAWN_READY_TIMEOUT_MS = 15e3;
+function killSpawnedChild(child, pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }
+}
 function spawnToolsServer(paths, port, options = {}) {
   return new Promise((resolve3, reject) => {
     let logFd;
@@ -15565,6 +15579,10 @@ function spawnToolsServer(paths, port, options = {}) {
       settled = true;
       fn();
     };
+    const rejectAndKill = (err) => settle(() => {
+      killSpawnedChild(child, pid);
+      reject(err);
+    });
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
       const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
@@ -15577,7 +15595,7 @@ function spawnToolsServer(paths, port, options = {}) {
     });
     child.on("error", (err) => {
       rl.close();
-      settle(() => reject(err));
+      rejectAndKill(err);
     });
     child.on("exit", (code) => {
       rl.close();
@@ -15585,8 +15603,8 @@ function spawnToolsServer(paths, port, options = {}) {
     });
     const timer = setTimeout(() => {
       rl.close();
-      settle(() => reject(new Error("Timed out waiting for tools server to become ready")));
-    }, 15e3);
+      rejectAndKill(new Error("Timed out waiting for tools server to become ready"));
+    }, options.readyTimeoutMs ?? SPAWN_READY_TIMEOUT_MS);
     rl.on("close", () => clearTimeout(timer));
   });
 }
@@ -15623,37 +15641,146 @@ async function clearToolsServerState() {
 var readState = readToolsServerState;
 var writeState = writeToolsServerState;
 var clearState = clearToolsServerState;
-async function ensureToolsServer(paths) {
-  const state = await readState();
-  if (state) {
-    const alive = isProcessAlive(state.pid);
-    if (alive) {
-      const host = state.host ?? "127.0.0.1";
-      const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
-      if (healthy) {
-        return {
-          url: formatUrl(healthCheckHost(host), state.port),
-          token: state.token ?? ""
-        };
+var SIGTERM_GRACE_MS = 6e3;
+var SIGKILL_GRACE_MS = 1e3;
+var KILL_POLL_MS = 100;
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, KILL_POLL_MS));
+  }
+  return !isProcessAlive(pid);
+}
+async function terminatePid(pid, stillOurs) {
+  if (!isProcessAlive(pid)) return;
+  if (stillOurs && !stillOurs()) return;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  if (await waitForExit(pid, SIGTERM_GRACE_MS)) return;
+  if (stillOurs && !(isProcessAlive(pid) && stillOurs())) return;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return;
+  }
+  await waitForExit(pid, SIGKILL_GRACE_MS);
+}
+function processCommandMatches(pid, marker) {
+  if (!marker) return false;
+  try {
+    const cmd = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!cmd) return false;
+    const argv = cmd.split(/\s+/);
+    return argv.includes(marker) && argv.includes("start");
+  } catch {
+    return false;
+  }
+}
+var LOCK_WAIT_TIMEOUT_MS = 3e4;
+var LOCK_STALE_MS = 45e3;
+var LOCK_POLL_MS = 100;
+function spawnLockIsStale() {
+  try {
+    const { pid, ts } = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8"));
+    if (typeof pid === "number" && pid > 0 && !isProcessAlive(pid)) return true;
+    if (typeof ts === "number" && Date.now() - ts > LOCK_STALE_MS) return true;
+    return false;
+  } catch {
+    try {
+      return Date.now() - fs.statSync(LOCK_FILE).mtimeMs > LOCK_STALE_MS;
+    } catch {
+      return true;
+    }
+  }
+}
+async function acquireSpawnLock() {
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  } catch {
+    return null;
+  }
+  const nonce = randomBytes(8).toString("hex");
+  const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      const fd = fs.openSync(LOCK_FILE, "wx");
+      try {
+        fs.writeSync(fd, JSON.stringify({ pid: process.pid, nonce, ts: Date.now() }));
+      } finally {
+        fs.closeSync(fd);
+      }
+      let released = false;
+      return {
+        release: () => {
+          if (released) return;
+          released = true;
+          try {
+            const cur = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8"));
+            if (cur.pid === process.pid && cur.nonce === nonce) fs.unlinkSync(LOCK_FILE);
+          } catch {
+          }
+        }
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+      if (spawnLockIsStale()) {
+        try {
+          fs.unlinkSync(LOCK_FILE);
+        } catch {
+        }
+        if (!fs.existsSync(LOCK_FILE)) continue;
       }
+      if (Date.now() >= deadline) return null;
+      await new Promise((r) => setTimeout(r, LOCK_POLL_MS));
+    }
+  }
+}
+async function reusableHandle(state) {
+  if (!state || !isProcessAlive(state.pid)) return null;
+  const host = state.host ?? "127.0.0.1";
+  const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
+  if (!healthy) return null;
+  return { url: formatUrl(healthCheckHost(host), state.port), token: state.token ?? "" };
+}
+async function ensureToolsServer(paths) {
+  const fast = await reusableHandle(await readState());
+  if (fast) return fast;
+  const lock = await acquireSpawnLock();
+  try {
+    const state = await readState();
+    const reuse = await reusableHandle(state);
+    if (reuse) return reuse;
+    if (state && state.managed === "autospawn" && isProcessAlive(state.pid) && processCommandMatches(state.pid, state.bundlePath)) {
+      await terminatePid(state.pid, () => processCommandMatches(state.pid, state.bundlePath));
     }
     await clearState();
+    const token = generateToken();
+    const port = await findFreePort();
+    const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+      token,
+      idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
+    });
+    await writeState({
+      port: actualPort,
+      pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      bundlePath: paths.bundlePath,
+      host: "127.0.0.1",
+      token,
+      managed: "autospawn"
+    });
+    return { url: formatUrl("127.0.0.1", actualPort), token };
+  } finally {
+    lock?.release();
   }
-  const token = generateToken();
-  const port = await findFreePort();
-  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
-    token,
-    idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
-  });
-  await writeState({
-    port: actualPort,
-    pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundlePath: paths.bundlePath,
-    host: "127.0.0.1",
-    token
-  });
-  return { url: formatUrl("127.0.0.1", actualPort), token };
 }
 
 // ../argent-tools-client/src/link-config.ts
@@ -15927,37 +16054,6 @@ function getDeviceIdFromArgs(args) {
   return void 0;
 }
 
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname2, posix, sep } from "path";
-function createModulerModifier() {
-  const getModuleFromFileName = createGetModuleFromFilename();
-  return async (frames) => {
-    for (const frame of frames) frame.module = getModuleFromFileName(frame.filename);
-    return frames;
-  };
-}
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
-  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
-  return (filename) => {
-    if (!filename) return;
-    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
-    let { dir, base: file, ext } = posix.parse(normalizedFilename);
-    if (".js" === ext || ".mjs" === ext || ".cjs" === ext) file = file.slice(0, -1 * ext.length);
-    const decodedFile = decodeURIComponent(file);
-    if (!dir) dir = ".";
-    const n = dir.lastIndexOf("/node_modules");
-    if (n > -1) return `${dir.slice(n + 14).replace(/\//g, ".")}:${decodedFile}`;
-    if (dir.startsWith(normalizedBase)) {
-      const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, ".");
-      return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
-    }
-    return decodedFile;
-  };
-}
-function normalizeWindowsPath(path9) {
-  return path9.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
-}
-
 // ../../node_modules/@posthog/core/dist/utils/type-utils.mjs
 var nativeIsArray = Array.isArray;
 var ObjProto = Object.prototype;
@@ -15992,65 +16088,6 @@ function isInstanceOf(candidate, base) {
   }
 }
 
-// ../../node_modules/@posthog/core/dist/utils/number-utils.mjs
-function clampToRange(value, min, max, logger, fallbackValue) {
-  if (min > max) {
-    logger.warn("min cannot be greater than max.");
-    min = max;
-  }
-  if (isNumber(value)) if (value > max) {
-    logger.warn(" cannot be  greater than max: " + max + ". Using max value instead.");
-    return max;
-  } else {
-    if (!(value < min)) return value;
-    logger.warn(" cannot be less than min: " + min + ". Using min value instead.");
-    return min;
-  }
-  logger.warn(" must be a number. using max or fallback. max: " + max + ", fallback: " + fallbackValue);
-  return clampToRange(fallbackValue || max, min, max, logger);
-}
-
-// ../../node_modules/@posthog/core/dist/utils/bucketed-rate-limiter.mjs
-var ONE_DAY_IN_MS = 864e5;
-var BucketedRateLimiter = class {
-  constructor(options) {
-    this._buckets = {};
-    this._onBucketRateLimited = options._onBucketRateLimited;
-    this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger);
-    this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger);
-    this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
-  }
-  _applyRefill(bucket, now) {
-    const elapsedMs = now - bucket.lastAccess;
-    const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
-    if (refillIntervals > 0) {
-      const tokensToAdd = refillIntervals * this._refillRate;
-      bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
-      bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
-    }
-  }
-  consumeRateLimit(key) {
-    const now = Date.now();
-    const keyStr = String(key);
-    let bucket = this._buckets[keyStr];
-    if (bucket) this._applyRefill(bucket, now);
-    else {
-      bucket = {
-        tokens: this._bucketSize,
-        lastAccess: now
-      };
-      this._buckets[keyStr] = bucket;
-    }
-    if (0 === bucket.tokens) return true;
-    bucket.tokens--;
-    if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
-    return 0 === bucket.tokens;
-  }
-  stop() {
-    this._buckets = {};
-  }
-};
-
 // ../../node_modules/@posthog/core/dist/utils/user-agent-utils.mjs
 var MOBILE = "Mobile";
 var IOS = "iOS";
@@ -16087,6 +16124,14 @@ var GENERIC_MOBILE = GENERIC + " " + MOBILE.toLowerCase();
 var GENERIC_TABLET = GENERIC + " " + TABLET.toLowerCase();
 var KONQUEROR = "Konqueror";
 var OCULUS_BROWSER = "Oculus Browser";
+var VIVALDI = "Vivaldi";
+var YANDEX = "Yandex";
+var WHALE = "Whale";
+var DUCKDUCKGO = "DuckDuckGo";
+var PALE_MOON = "Pale Moon";
+var WATERFOX = "Waterfox";
+var BRAVE = "Brave";
+var GOOGLE_SEARCH_APP = "Google Search App";
 var BROWSER_VERSION_REGEX_SUFFIX = "(\\d+(\\.\\d+)?)";
 var DEFAULT_BROWSER_VERSION_REGEX = new RegExp("Version/" + BROWSER_VERSION_REGEX_SUFFIX);
 var XBOX_REGEX = new RegExp(XBOX, "i");
@@ -16153,6 +16198,30 @@ var versionRegexes = {
   [OCULUS_BROWSER]: [
     new RegExp("OculusBrowser\\/" + BROWSER_VERSION_REGEX_SUFFIX)
   ],
+  [VIVALDI]: [
+    new RegExp(VIVALDI + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [YANDEX]: [
+    new RegExp("YaBrowser\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [WHALE]: [
+    new RegExp(WHALE + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [BRAVE]: [
+    new RegExp(BRAVE + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [DUCKDUCKGO]: [
+    new RegExp("(DuckDuckGo|Ddg)\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [PALE_MOON]: [
+    new RegExp("PaleMoon\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [WATERFOX]: [
+    new RegExp(WATERFOX + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [GOOGLE_SEARCH_APP]: [
+    new RegExp("GSA\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
   [INTERNET_EXPLORER]: [
     new RegExp("(rv:|MSIE )" + BROWSER_VERSION_REGEX_SUFFIX)
   ],
@@ -17131,301 +17200,6 @@ import { createReadStream } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline";
 var LRU_FILE_CONTENTS_CACHE = new error_tracking_exports.ReduceableCache(25);
 var LRU_FILE_CONTENTS_FS_READ_FAILED = new error_tracking_exports.ReduceableCache(20);
-var DEFAULT_LINES_OF_CONTEXT = 7;
-var MAX_CONTEXTLINES_COLNO = 1e3;
-var MAX_CONTEXTLINES_LINENO = 1e4;
-async function addSourceContext(frames) {
-  const filesToLines = {};
-  for (let i = frames.length - 1; i >= 0; i--) {
-    const frame = frames[i];
-    const filename = frame?.filename;
-    if (!frame || "string" != typeof filename || "number" != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
-    const filesToLinesOutput = filesToLines[filename];
-    if (!filesToLinesOutput) filesToLines[filename] = [];
-    filesToLines[filename].push(frame.lineno);
-  }
-  const files = Object.keys(filesToLines);
-  if (0 == files.length) return frames;
-  const readlinePromises = [];
-  for (const file of files) {
-    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) continue;
-    const filesToLineRanges = filesToLines[file];
-    if (!filesToLineRanges) continue;
-    filesToLineRanges.sort((a, b) => a - b);
-    const ranges = makeLineReaderRanges(filesToLineRanges);
-    if (ranges.every((r) => rangeExistsInContentCache(file, r))) continue;
-    const cache2 = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
-    readlinePromises.push(getContextLinesFromFile(file, ranges, cache2));
-  }
-  await Promise.all(readlinePromises).catch(() => {
-  });
-  if (frames && frames.length > 0) addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
-  LRU_FILE_CONTENTS_CACHE.reduce();
-  return frames;
-}
-function getContextLinesFromFile(path9, ranges, output) {
-  return new Promise((resolve3) => {
-    const stream = createReadStream(path9);
-    const lineReaded = createInterface2({
-      input: stream
-    });
-    function destroyStreamAndResolve() {
-      stream.destroy();
-      resolve3();
-    }
-    let lineNumber = 0;
-    let currentRangeIndex = 0;
-    const range = ranges[currentRangeIndex];
-    if (void 0 === range) return void destroyStreamAndResolve();
-    let rangeStart = range[0];
-    let rangeEnd = range[1];
-    function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path9, 1);
-      lineReaded.close();
-      lineReaded.removeAllListeners();
-      destroyStreamAndResolve();
-    }
-    stream.on("error", onStreamError);
-    lineReaded.on("error", onStreamError);
-    lineReaded.on("close", destroyStreamAndResolve);
-    lineReaded.on("line", (line) => {
-      lineNumber++;
-      if (lineNumber < rangeStart) return;
-      output[lineNumber] = snipLine(line, 0);
-      if (lineNumber >= rangeEnd) {
-        if (currentRangeIndex === ranges.length - 1) {
-          lineReaded.close();
-          lineReaded.removeAllListeners();
-          return;
-        }
-        currentRangeIndex++;
-        const range2 = ranges[currentRangeIndex];
-        if (void 0 === range2) {
-          lineReaded.close();
-          lineReaded.removeAllListeners();
-          return;
-        }
-        rangeStart = range2[0];
-        rangeEnd = range2[1];
-      }
-    });
-  });
-}
-function addSourceContextToFrames(frames, cache2) {
-  for (const frame of frames) if (frame.filename && void 0 === frame.context_line && "number" == typeof frame.lineno) {
-    const contents = cache2.get(frame.filename);
-    if (void 0 === contents) continue;
-    addContextToFrame(frame.lineno, frame, contents);
-  }
-}
-function addContextToFrame(lineno, frame, contents) {
-  if (void 0 === frame.lineno || void 0 === contents) return;
-  frame.pre_context = [];
-  for (let i = makeRangeStart(lineno); i < lineno; i++) {
-    const line = contents[i];
-    if (void 0 === line) return void clearLineContext(frame);
-    frame.pre_context.push(line);
-  }
-  if (void 0 === contents[lineno]) return void clearLineContext(frame);
-  frame.context_line = contents[lineno];
-  const end = makeRangeEnd(lineno);
-  frame.post_context = [];
-  for (let i = lineno + 1; i <= end; i++) {
-    const line = contents[i];
-    if (void 0 === line) break;
-    frame.post_context.push(line);
-  }
-}
-function clearLineContext(frame) {
-  delete frame.pre_context;
-  delete frame.context_line;
-  delete frame.post_context;
-}
-function shouldSkipContextLinesForFile(path9) {
-  return path9.startsWith("node:") || path9.endsWith(".min.js") || path9.endsWith(".min.cjs") || path9.endsWith(".min.mjs") || path9.startsWith("data:");
-}
-function shouldSkipContextLinesForFrame(frame) {
-  if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
-  if (void 0 !== frame.colno && frame.colno > MAX_CONTEXTLINES_COLNO) return true;
-  return false;
-}
-function rangeExistsInContentCache(file, range) {
-  const contents = LRU_FILE_CONTENTS_CACHE.get(file);
-  if (void 0 === contents) return false;
-  for (let i = range[0]; i <= range[1]; i++) if (void 0 === contents[i]) return false;
-  return true;
-}
-function makeLineReaderRanges(lines) {
-  if (!lines.length) return [];
-  let i = 0;
-  const line = lines[0];
-  if ("number" != typeof line) return [];
-  let current = makeContextRange(line);
-  const out = [];
-  while (true) {
-    if (i === lines.length - 1) {
-      out.push(current);
-      break;
-    }
-    const next = lines[i + 1];
-    if ("number" != typeof next) break;
-    if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
-    else {
-      out.push(current);
-      current = makeContextRange(next);
-    }
-    i++;
-  }
-  return out;
-}
-function makeContextRange(line) {
-  return [
-    makeRangeStart(line),
-    makeRangeEnd(line)
-  ];
-}
-function makeRangeStart(line) {
-  return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
-}
-function makeRangeEnd(line) {
-  return line + DEFAULT_LINES_OF_CONTEXT;
-}
-function emplace(map, key, contents) {
-  const value = map.get(key);
-  if (void 0 === value) {
-    map.set(key, contents);
-    return contents;
-  }
-  return value;
-}
-function snipLine(line, colno) {
-  let newLine = line;
-  const lineLength = newLine.length;
-  if (lineLength <= 150) return newLine;
-  if (colno > lineLength) colno = lineLength;
-  let start = Math.max(colno - 60, 0);
-  if (start < 5) start = 0;
-  let end = Math.min(start + 140, lineLength);
-  if (end > lineLength - 5) end = lineLength;
-  if (end === lineLength) start = Math.max(end - 140, 0);
-  newLine = newLine.slice(start, end);
-  if (start > 0) newLine = `...${newLine}`;
-  if (end < lineLength) newLine += "...";
-  return newLine;
-}
-
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute2, relative, sep as sep2 } from "path";
-function createRelativePathModifier(basePath = process.cwd()) {
-  const isWindows = "\\" === sep2;
-  const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
-  const normalizedBase = toUnix(basePath);
-  return async (frames) => {
-    for (const frame of frames) if (!(!frame.filename || frame.filename.startsWith("node:") || frame.filename.startsWith("data:"))) {
-      if (isAbsolute2(frame.filename)) frame.filename = toUnix(relative(normalizedBase, toUnix(frame.filename)));
-    }
-    return frames;
-  };
-}
-
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/autocapture.mjs
-function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
-  let calledFatalError = false;
-  return Object.assign((error2) => {
-    const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => "domainUncaughtExceptionClear" !== listener.name && true !== listener._posthogErrorHandler).length;
-    const processWouldExit = 0 === userProvidedListenersCount;
-    captureFn(error2, {
-      mechanism: {
-        type: "onuncaughtexception",
-        handled: false
-      }
-    });
-    if (!calledFatalError && processWouldExit) {
-      calledFatalError = true;
-      onFatalFn(error2);
-    }
-  }, {
-    _posthogErrorHandler: true
-  });
-}
-function addUncaughtExceptionListener(captureFn, onFatalFn) {
-  globalThis.process?.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
-}
-function addUnhandledRejectionListener(captureFn) {
-  globalThis.process?.on("unhandledRejection", (reason) => captureFn(reason, {
-    mechanism: {
-      type: "onunhandledrejection",
-      handled: false
-    }
-  }));
-}
-
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/index.mjs
-var SHUTDOWN_TIMEOUT = 2e3;
-var ErrorTracking = class _ErrorTracking {
-  constructor(client, options, _logger) {
-    this.client = client;
-    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
-    this._logger = _logger;
-    this._rateLimiter = new BucketedRateLimiter({
-      refillRate: 1,
-      bucketSize: 10,
-      refillInterval: 1e4,
-      _logger: this._logger
-    });
-    this.startAutocaptureIfEnabled();
-  }
-  static isPreviouslyCapturedError(x) {
-    return isObject2(x) && "__posthog_previously_captured_error" in x && true === x.__posthog_previously_captured_error;
-  }
-  static async buildEventMessage(error2, hint, distinctId, additionalProperties) {
-    const properties = {
-      ...additionalProperties
-    };
-    const exceptionProperties = this.errorPropertiesBuilder.buildFromUnknown(error2, hint);
-    exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
-    return {
-      event: "$exception",
-      distinctId,
-      properties: {
-        ...exceptionProperties,
-        ...properties
-      },
-      _originatedFromCaptureException: true
-    };
-  }
-  startAutocaptureIfEnabled() {
-    if (this.isEnabled()) {
-      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
-      addUnhandledRejectionListener(this.onException.bind(this));
-    }
-  }
-  onException(exception, hint) {
-    this.client.addPendingPromise((async () => {
-      if (!_ErrorTracking.isPreviouslyCapturedError(exception)) {
-        const eventMessage = await _ErrorTracking.buildEventMessage(exception, hint);
-        const exceptionProperties = eventMessage.properties;
-        const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? "Exception";
-        const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
-        if (isRateLimited) return void this._logger.info("Skipping exception capture because of client rate limiting.", {
-          exception: exceptionType
-        });
-        return this.client.capture(eventMessage);
-      }
-    })());
-  }
-  async onFatalError(exception) {
-    console.error(exception);
-    await this.client.shutdown(SHUTDOWN_TIMEOUT);
-    process.exit(1);
-  }
-  isEnabled() {
-    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
-  }
-  shutdown() {
-    this._rateLimiter.stop();
-  }
-};
 
 // ../../node_modules/posthog-node/dist/extensions/context/context.mjs
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -17494,19 +17268,6 @@ var PostHogSentryIntegration = class {
   }
 };
 
-// ../../node_modules/posthog-node/dist/entrypoints/index.node.mjs
-ErrorTracking.errorPropertiesBuilder = new error_tracking_exports.ErrorPropertiesBuilder([
-  new error_tracking_exports.EventCoercer(),
-  new error_tracking_exports.ErrorCoercer(),
-  new error_tracking_exports.ObjectCoercer(),
-  new error_tracking_exports.StringCoercer(),
-  new error_tracking_exports.PrimitiveCoercer()
-], error_tracking_exports.createStackParser("node:javascript", error_tracking_exports.nodeStackLineParser), [
-  createModulerModifier(),
-  addSourceContext,
-  createRelativePathModifier()
-]);
-
 // ../registry/src/artifacts.ts
 import { stat as stat3 } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -17741,7 +17502,7 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // ../telemetry/src/events.ts
-var PLATFORMS = ["ios", "android", "chromium", "vega"];
+var PLATFORMS = ["ios", "ios-remote", "android", "chromium", "vega"];
 
 // ../telemetry/src/ai-identity.ts
 var AI_CLIENTS = [
@@ -17946,6 +17707,9 @@ var ALLOWED = {
 // ../telemetry/src/base-props.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 
+// ../telemetry/src/cloud-agent-detect.ts
+import { existsSync as existsSync2 } from "node:fs";
+
 // ../../node_modules/ci-info/vendors.json
 var vendors_default = [
   {
@@ -18356,7 +18120,7 @@ function readConfigObject() {
   }
   return {};
 }
-var LOCK_STALE_MS = 1e4;
+var LOCK_STALE_MS2 = 1e4;
 var LOCK_MAX_WAIT_MS = 2e3;
 var LOCK_RETRY_MS = 25;
 function sleepSync(ms) {
@@ -18377,7 +18141,7 @@ function acquireConfigLock() {
     } catch (err) {
       if (err.code !== "EEXIST") return null;
       try {
-        if (Date.now() - fs3.statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+        if (Date.now() - fs3.statSync(lockPath).mtimeMs > LOCK_STALE_MS2) {
           fs3.unlinkSync(lockPath);
           continue;
         }
@@ -18546,9 +18310,16 @@ function imageBlock(data, mimeType) {
 }
 async function fetchPngBytes(url) {
   try {
-    const res = await fetch(url);
-    if (!res.ok) return null;
-    const buf = Buffer.from(await res.arrayBuffer());
+    let buf;
+    if (url.startsWith("file://")) {
+      const { readFile: readFile6 } = await import("node:fs/promises");
+      const { fileURLToPath } = await import("node:url");
+      buf = await readFile6(fileURLToPath(url));
+    } else {
+      const res = await fetch(url);
+      if (!res.ok) return null;
+      buf = Buffer.from(await res.arrayBuffer());
+    }
     if (buf.length < PNG_SIGNATURE.length) return null;
     if (!buf.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) return null;
     return buf;
@@ -18899,7 +18670,7 @@ async function startMcpServer(options) {
   async function spyLog(entry) {
     try {
       if (!logDirReady) {
-        await mkdir5(dirname4(LOG_FILE2), { recursive: true });
+        await mkdir5(dirname3(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");