@swmansion/argent 0.15.0 → 0.15.1-next.0

package/dist/cli-cmds.mjs

@@ -204,7 +204,7 @@ function generateAuthToken() {
   return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -215,7 +215,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve4(port);
+        else resolve6(port);
       });
     });
     srv.on("error", reject);
@@ -316,7 +316,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -353,7 +353,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve4({ port: actualPort, pid }));
+        settle(() => resolve6({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -729,16 +729,122 @@ function parseLinkTarget(input) {
   const host = u3.hostname.startsWith("[") ? u3.hostname.slice(1, -1) : u3.hostname;
   if (!host) throw new Error(`URL "${input}" is missing a host.`);
   const port = u3.port ? Number(u3.port) : u3.protocol === "https:" ? 443 : 80;
-  const path13 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url = `${u3.protocol}//${u3.host}${path13}`;
+  const path14 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url = `${u3.protocol}//${u3.host}${path14}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url, host, port, ...token ? { token } : {} };
 }
 
 // ../argent-tools-client/src/file-inputs.ts
-import { mkdir as mkdir3, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { readFile as readFile3 } from "node:fs/promises";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import * as path3 from "node:path";
+
+// ../archive/src/index.ts
+import { execFile } from "node:child_process";
+import { rm, readdir as readdir2 } from "node:fs/promises";
+import { basename, dirname as dirname2, join as join3, posix, resolve as resolve2, sep } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var ArchiveError = class extends Error {
+};
+function createTarGzArgs(sourcePath, target) {
+  return ["-czf", target, "-C", dirname2(sourcePath), basename(sourcePath)];
+}
+async function createTarGzFile(sourcePath, tarPath) {
+  try {
+    await execFileAsync("tar", createTarGzArgs(sourcePath, tarPath));
+  } catch (err) {
+    await rm(tarPath, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+function normalizeTarMemberPath(memberPath) {
+  return memberPath.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function isSafeTarMember(memberPath, destDir) {
+  const normalized = normalizeTarMemberPath(memberPath);
+  if (!normalized || normalized === "." || normalized === "./") return false;
+  if (normalized.startsWith("/") || /^[A-Za-z]:[\\/]/.test(normalized)) return false;
+  const relative4 = posix.normalize(normalized);
+  if (relative4 === ".." || relative4.startsWith("../") || relative4.split("/").includes("..")) {
+    return false;
+  }
+  const root = resolve2(destDir);
+  const resolved = resolve2(destDir, relative4);
+  return resolved === root || resolved.startsWith(root + sep);
+}
+async function listTarMembers(tarPath) {
+  const { stdout: stdout2 } = await execFileAsync("tar", ["-tzf", tarPath]);
+  return stdout2.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isEscapingLinkTarget(target) {
+  if (target.startsWith("/") || /^[A-Za-z]:[\\/]/.test(target)) return true;
+  return posix.normalize(target.replace(/\\/g, "/")).split("/").includes("..");
+}
+async function assertSafeMemberTypes(tarPath) {
+  const { stdout: stdout2 } = await execFileAsync("tar", ["-tzvf", tarPath]);
+  for (const line of stdout2.split("\n")) {
+    if (!line.trim()) continue;
+    const type = line[0];
+    if (type === "-" || type === "d") continue;
+    if (type === "l") {
+      const parts = line.split(" -> ");
+      const target = parts.length === 2 ? parts[1].trim() : "";
+      if (parts.length !== 2 || !target || isEscapingLinkTarget(target)) {
+        throw new ArchiveError(
+          `Archive contains a symlink whose target could not be confirmed safe: "${line.trim()}".`
+        );
+      }
+      continue;
+    }
+    throw new ArchiveError(
+      `Archive contains an unsupported member type "${type}" (hardlink/device/\u2026) \u2014 refusing extraction.`
+    );
+  }
+}
+async function assertSafeArchive(tarPath, destDir) {
+  let members;
+  try {
+    members = await listTarMembers(tarPath);
+  } catch (err) {
+    throw new ArchiveError(
+      `Could not read archive: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (members.length === 0) {
+    throw new ArchiveError("Archive is empty.");
+  }
+  for (const member of members) {
+    if (!isSafeTarMember(member, destDir)) {
+      throw new ArchiveError(`Archive contains an unsafe path "${member}" \u2014 refusing extraction.`);
+    }
+  }
+  await assertSafeMemberTypes(tarPath);
+}
+async function resolveMember(destDir, expectedName) {
+  const entries = await readdir2(destDir);
+  if (entries.includes(expectedName)) {
+    return join3(destDir, expectedName);
+  }
+  const real = entries.filter((e) => !e.startsWith("._"));
+  if (real.length !== 1) {
+    throw new ArchiveError(
+      `Could not identify the extracted member (expected "${expectedName}", found ${real.length} entries).`
+    );
+  }
+  return join3(destDir, real[0]);
+}
+async function safeExtractTarGz(tarPath, destDir, expectedName) {
+  await assertSafeArchive(tarPath, destDir);
+  await execFileAsync("tar", ["-xzf", tarPath, "-C", destDir]);
+  return resolveMember(destDir, expectedName);
+}
+
+// ../argent-tools-client/src/file-inputs.ts
 var FILE_INPUT_MARKER = "__argentFileInput";
 var CLIENT_FILE_MARKER = "__argentClientFile";
 var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
@@ -754,6 +860,34 @@ function interpolatePath(template, args) {
   });
   return missing ? null : out;
 }
+async function tarball(sourcePath) {
+  const tarPath = path3.join(tmpdir(), `argent-upload-${randomUUID()}.tar.gz`);
+  await createTarGzFile(sourcePath, tarPath);
+  return tarPath;
+}
+function sha256File(filePath) {
+  return new Promise((resolve6, reject) => {
+    const hash = createHash2("sha256");
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve6(hash.digest("hex"))).on("error", reject);
+  });
+}
+async function uploadTar(tarPath, endpoint) {
+  const init2 = {
+    method: "POST",
+    headers: {
+      "content-type": "application/gzip",
+      ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
+    },
+    body: createReadStream(tarPath),
+    duplex: "half"
+  };
+  const res = await fetch(`${endpoint.url}/upload`, init2);
+  if (!res.ok) {
+    throw new Error(`Upload to ${endpoint.url}/upload failed: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return json.uploadId;
+}
 async function prepareFileInputs(specs, args, opts) {
   if (!specs || specs.length === 0 || typeof args !== "object" || args === null) {
     return args;
@@ -781,6 +915,28 @@ async function prepareFileInputs(specs, args, opts) {
       } catch {
       }
     }
+    if (spec.kind === "tar-upload") {
+      const st = await stat(filePath).catch(() => null);
+      if (st) {
+        wire.size = st.size;
+        wire.mtimeMs = st.mtimeMs;
+      }
+      if (opts.uploadEndpoint && st) {
+        let tarPath = null;
+        try {
+          process.stderr.write(
+            `Uploading ${path3.basename(filePath)} to the remote tool-server...
+`
+          );
+          tarPath = await tarball(filePath);
+          wire.contentHash = await sha256File(tarPath);
+          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint);
+        } finally {
+          if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    }
     out = out ?? { ...record };
     out[spec.target] = wire;
   }
@@ -831,6 +987,43 @@ async function applyClientFileDirectives(result) {
 function authHeaders2(token) {
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
+async function consumeToolStream(body, onProgress) {
+  let final;
+  const handleLine = (line) => {
+    if (!line.trim()) return;
+    const msg = JSON.parse(line);
+    if (msg.event === "progress") onProgress(msg.data);
+    else if (msg.event === "result") final = { data: msg.data, note: msg.note };
+    else if (msg.event === "error") throw new Error(msg.error ?? "tool invocation failed");
+  };
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffered.indexOf("\n")) !== -1) {
+        const line = buffered.slice(0, newline);
+        buffered = buffered.slice(newline + 1);
+        handleLine(line);
+      }
+    }
+    buffered += decoder.decode();
+    if (buffered.trim()) handleLine(buffered);
+  } catch (err) {
+    void reader.cancel().catch(() => {
+    });
+    throw err;
+  }
+  if (!final) {
+    throw new Error("tool stream ended without a result \u2014 connection lost mid-run?");
+  }
+  const { result: data } = await applyClientFileDirectives(final.data);
+  return { data, note: final.note };
+}
 function createToolsClient(options = {}) {
   let cached2 = null;
   async function baseUrl() {
@@ -858,21 +1051,31 @@ function createToolsClient(options = {}) {
     const tools2 = await fetchTools();
     return tools2.find((t2) => t2.name === name) ?? null;
   }
-  async function callTool(name, args) {
+  async function callTool(name, args, opts) {
     const { url, token } = await baseUrl();
     let finalArgs = args;
     const meta = await fetchTool(name);
     if (meta?.fileInputs?.length) {
       const { url: routedUrl } = await getResolvedToolsUrl();
+      const isRemote = routedUrl !== null;
       finalArgs = await prepareFileInputs(meta.fileInputs, args ?? {}, {
-        includeContent: routedUrl !== null
+        includeContent: isRemote,
+        uploadEndpoint: isRemote ? { url, token } : void 0
       });
     }
     const res = await fetch(`${url}/tools/${encodeURIComponent(name)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...authHeaders2(token) },
+      headers: {
+        "Content-Type": "application/json",
+        ...opts?.onProgress ? { Accept: "application/x-ndjson" } : {},
+        ...authHeaders2(token)
+      },
       body: JSON.stringify(finalArgs ?? {})
     });
+    const contentType = res.headers.get("content-type") ?? "";
+    if (opts?.onProgress && res.ok && res.body && contentType.includes("application/x-ndjson")) {
+      return consumeToolStream(res.body, opts.onProgress);
+    }
     const json = await res.json().catch(() => ({}));
     if (!res.ok) {
       throw new Error(json.error ?? json.message ?? `${res.status} ${res.statusText}`);
@@ -884,13 +1087,10 @@ function createToolsClient(options = {}) {
 }
 
 // ../argent-tools-client/src/artifacts.ts
-import { mkdir as mkdir4, readFile as readFile4, rm, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, join as join3 } from "node:path";
-import { createHash as createHash2 } from "node:crypto";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { mkdir as mkdir4, readFile as readFile4, rm as rm3, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, join as join5 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
 var ARTIFACT_MARKER = "__argentArtifact";
 function isArtifactHandle(value) {
   return !!value && typeof value === "object" && value[ARTIFACT_MARKER] === true && typeof value.id === "string" && typeof value.filename === "string";
@@ -908,17 +1108,17 @@ function sanitizeSegment(segment) {
 }
 function projectSlug() {
   const cwd = process.cwd();
-  const hash = createHash2("sha1").update(cwd).digest("hex").slice(0, 6);
-  const name = sanitizeSegment(basename(cwd)) || "root";
+  const hash = createHash3("sha1").update(cwd).digest("hex").slice(0, 6);
+  const name = sanitizeSegment(basename3(cwd)) || "root";
   return `${name}-${hash}`;
 }
 function artifactsRoot() {
-  return process.env.ARGENT_ARTIFACTS_DIR ?? join3(tmpdir(), "argent-artifacts");
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join5(tmpdir2(), "argent-artifacts");
 }
 function artifactDir(deviceId) {
   const parts = [artifactsRoot(), projectSlug(), sessionId()];
   if (deviceId) parts.push(sanitizeSegment(deviceId));
-  return join3(...parts);
+  return join5(...parts);
 }
 async function resolveLocalFile(handle) {
   if (!handle.hostPath) return null;
@@ -938,15 +1138,14 @@ async function resolveLocalFile(handle) {
   }
 }
 async function downloadAndExtractArchive(handle, data, dir) {
-  const tarball = join3(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  const tarball2 = join5(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
   try {
-    await writeFile4(tarball, data);
-    await execFileAsync("tar", ["-xzf", tarball, "-C", dir]);
-    return join3(dir, handle.filename);
+    await writeFile4(tarball2, data);
+    return await safeExtractTarGz(tarball2, dir, handle.filename);
   } catch {
     return null;
   } finally {
-    await rm(tarball, { force: true }).catch(() => {
+    await rm3(tarball2, { force: true }).catch(() => {
     });
   }
 }
@@ -982,7 +1181,7 @@ async function materializeArtifacts(result, ctx) {
           return await downloadAndExtractArchive(value, data, dir);
         }
         if (value.size > 0 && data.length !== value.size) return null;
-        const downloadedPath = join3(dir, sanitizeSegment(value.filename));
+        const downloadedPath = join5(dir, sanitizeSegment(value.filename));
         await writeFile4(downloadedPath, data);
         if (value.mimeType.startsWith("image/")) {
           images.push({ localPath: downloadedPath, data, mimeType: value.mimeType });
@@ -1016,7 +1215,7 @@ function getDeviceIdFromArgs(args) {
 }
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname3, posix, sep } from "path";
+import { dirname as dirname4, posix as posix2, sep as sep2 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -1024,12 +1223,12 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname3(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname4(process.argv[1]) : process.cwd(), isWindows = "\\" === sep2) {
   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);
+    let { dir, base: file, ext } = posix2.parse(normalizedFilename);
     if (".js" === ext || ".mjs" === ext || ".cjs" === ext) file = file.slice(0, -1 * ext.length);
     const decodedFile = decodeURIComponent(file);
     if (!dir) dir = ".";
@@ -1042,8 +1241,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname3(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path13) {
-  return path13.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path14) {
+  return path14.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -3559,7 +3758,7 @@ var PostHogCoreStateless = class {
 };
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
-import { createReadStream } from "node:fs";
+import { createReadStream as createReadStream2 } 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);
@@ -3595,15 +3794,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path13, ranges, output) {
-  return new Promise((resolve4) => {
-    const stream = createReadStream(path13);
+function getContextLinesFromFile(path14, ranges, output) {
+  return new Promise((resolve6) => {
+    const stream = createReadStream2(path14);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve4();
+      resolve6();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -3612,7 +3811,7 @@ function getContextLinesFromFile(path13, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path13, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path14, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3673,8 +3872,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path13) {
-  return path13.startsWith("node:") || path13.endsWith(".min.js") || path13.endsWith(".min.cjs") || path13.endsWith(".min.mjs") || path13.startsWith("data:");
+function shouldSkipContextLinesForFile(path14) {
+  return path14.startsWith("node:") || path14.endsWith(".min.js") || path14.endsWith(".min.cjs") || path14.endsWith(".min.mjs") || path14.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -3747,9 +3946,9 @@ function snipLine(line, colno) {
 }
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute3, relative as relative2, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute3, relative as relative2, sep as sep3 } from "path";
 function createRelativePathModifier(basePath = process.cwd()) {
-  const isWindows = "\\" === sep2;
+  const isWindows = "\\" === sep3;
   const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
   const normalizedBase = toUnix(basePath);
   return async (frames) => {
@@ -4900,9 +5099,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve4;
+      let resolve6;
       const promise = new Promise((r2) => {
-        resolve4 = r2;
+        resolve6 = r2;
       });
       try {
         waitUntil(promise);
@@ -4910,7 +5109,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve4,
+        resolve: resolve6,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -4934,12 +5133,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve4 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve4?.();
+      resolve6?.();
     }
   }
   getPersistedProperty(key) {
@@ -5060,15 +5259,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve4(false);
+        resolve6(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve4(count > 0);
+        resolve6(count > 0);
       });
     });
   }
@@ -5523,14 +5722,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve4 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve4?.();
+      resolve6?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -5908,8 +6107,8 @@ function resetClient() {
 
 // ../registry/src/artifacts.ts
 import { stat as stat3 } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { basename as basename2, extname } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { basename as basename4, extname } from "node:path";
 
 // ../registry/src/failure-codes.ts
 var FAILURE_CODES = {
@@ -5933,6 +6132,7 @@ var FAILURE_CODES = {
   TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
   TOOL_PLATFORM_NOT_IMPLEMENTED: "TOOL_PLATFORM_NOT_IMPLEMENTED",
   TOOL_DEPENDENCY_MISSING: "TOOL_DEPENDENCY_MISSING",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
   TOOLSERVER_UNHANDLED_REJECTION: "TOOLSERVER_UNHANDLED_REJECTION",
   TOOLSERVER_UNCAUGHT_EXCEPTION: "TOOLSERVER_UNCAUGHT_EXCEPTION",
   INSTALL_GLOBAL_PACKAGE_FAILED: "INSTALL_GLOBAL_PACKAGE_FAILED",
@@ -6005,6 +6205,7 @@ var FAILURE_CODES = {
   NATIVE_DEVTOOLS_FIND_VIEWS_ERROR: "NATIVE_DEVTOOLS_FIND_VIEWS_ERROR",
   NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING: "NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING",
   NATIVE_DEVTOOLS_WRONG_PLATFORM: "NATIVE_DEVTOOLS_WRONG_PLATFORM",
+  NATIVE_DEVTOOLS_NOT_INJECTABLE: "NATIVE_DEVTOOLS_NOT_INJECTABLE",
   NATIVE_DEVTOOLS_NOT_CONNECTED: "NATIVE_DEVTOOLS_NOT_CONNECTED",
   NATIVE_DEVTOOLS_RPC_TIMEOUT: "NATIVE_DEVTOOLS_RPC_TIMEOUT",
   NATIVE_DEVTOOLS_RPC_ERROR: "NATIVE_DEVTOOLS_RPC_ERROR",
@@ -6067,6 +6268,11 @@ var FAILURE_CODES = {
   NATIVE_PROFILER_NO_RUNNING_APPS: "NATIVE_PROFILER_NO_RUNNING_APPS",
   NATIVE_PROFILER_NO_RUNNING_USER_APPS: "NATIVE_PROFILER_NO_RUNNING_USER_APPS",
   NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS: "NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS",
+  NATIVE_PROFILER_MALLOC_DEGRADED_XCODE: "NATIVE_PROFILER_MALLOC_DEGRADED_XCODE",
+  NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE: "NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE",
+  NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED: "NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED",
+  NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND: "NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND",
+  NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS: "NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS",
   NATIVE_PROFILER_SESSION_ALREADY_RUNNING: "NATIVE_PROFILER_SESSION_ALREADY_RUNNING",
   NATIVE_PROFILER_XCTRACE_NO_PID: "NATIVE_PROFILER_XCTRACE_NO_PID",
   NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND: "NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND",
@@ -6089,6 +6295,8 @@ var FAILURE_CODES = {
   FLOW_NO_ACTIVE_RECORDING: "FLOW_NO_ACTIVE_RECORDING",
   FLOW_FILE_INVALID: "FLOW_FILE_INVALID",
   FLOW_ENTRY_UNRECOGNIZED: "FLOW_ENTRY_UNRECOGNIZED",
+  FLOW_E2E_HAS_PREREQUISITE: "FLOW_E2E_HAS_PREREQUISITE",
+  FLOW_DEVICE_RESOLUTION: "FLOW_DEVICE_RESOLUTION",
   PROFILER_QUERY_MODE_INVALID: "PROFILER_QUERY_MODE_INVALID",
   PROFILER_QUERY_REQUIRED_PARAM_MISSING: "PROFILER_QUERY_REQUIRED_PARAM_MISSING",
   PROFILER_DATA_NOT_LOADED: "PROFILER_DATA_NOT_LOADED",
@@ -6183,7 +6391,7 @@ var FAILURE_SIGNAL_NAME_SET = new Set(FAILURE_SIGNAL_NAMES);
 var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 
 // ../registry/src/registry.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../telemetry/src/events.ts
 var PLATFORMS = [
@@ -6392,6 +6600,39 @@ var ALLOWED = {
     uptime_ms: DURATION_MS,
     total_tool_calls: COUNT,
     ...FAILURE_SIGNAL
+  },
+  "lens:preview_opened": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    is_cli_session: bool,
+    platform: PLATFORM
+  },
+  "lens:round_completed": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    annotation_count: COUNT,
+    element_comment_count: COUNT,
+    skipped_comment_count: COUNT,
+    has_global_comment: bool,
+    inspector_used: bool,
+    offscreen_revealed: bool,
+    is_cli_session: bool,
+    had_parked_await: bool,
+    round_duration_ms: DURATION_MS,
+    platform: PLATFORM
+  },
+  "lens:round_abandoned": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    had_parked_await: bool,
+    is_cli_session: bool,
+    platform: PLATFORM
+  },
+  "lens:cli_session_started": {
+    agent_choice_count: COUNT
   }
 };
 function sanitize(event, raw) {
@@ -6408,7 +6649,7 @@ function sanitize(event, raw) {
 }
 
 // ../telemetry/src/base-props.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../telemetry/src/cloud-agent-detect.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -6442,9 +6683,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path13) {
+function safeExists(fileExists, path14) {
   try {
-    return fileExists(path13);
+    return fileExists(path14);
   } catch {
     return false;
   }
@@ -6862,7 +7103,7 @@ function isCi(env = process.env) {
 var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 
 // ../telemetry/src/base-props.ts
-var SESSION_ID2 = randomUUID3();
+var SESSION_ID2 = randomUUID4();
 function readCliVersion() {
   if (true) {
     return "0.15.0";
@@ -6921,6 +7162,10 @@ var FLAG_REGISTRY = [
   {
     name: "artifacts-list-endpoint",
     description: "Expose GET /artifacts for remote artifact inventory consumers."
+  },
+  {
+    name: "tool-server-event-log",
+    description: "Write structured tool-server lifecycle events to a JSONL file."
   }
 ];
 function getFlagDefinition(name, registry = FLAG_REGISTRY) {
@@ -7419,12 +7664,12 @@ function resolveHostFingerprint() {
   }
 }
 function resolveHostFingerprintAsync() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     let binary;
     try {
       binary = simulatorServerBinaryPath();
     } catch {
-      resolve4(null);
+      resolve6(null);
       return;
     }
     let settled = false;
@@ -7437,7 +7682,7 @@ function resolveHostFingerprintAsync() {
         child?.kill("SIGKILL");
       } catch {
       }
-      resolve4(value);
+      resolve6(value);
     };
     const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
     watchdog.unref?.();
@@ -7676,7 +7921,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve4) => setTimeout(resolve4, timeoutMs + 250).unref())
+      new Promise((resolve6) => setTimeout(resolve6, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -7696,7 +7941,7 @@ async function markDisabled() {
       try {
         await Promise.race([
           client2.shutdown(SHORT_FLUSH_TIMEOUT_MS),
-          new Promise((resolve4) => setTimeout(resolve4, SHORT_FLUSH_TIMEOUT_MS).unref())
+          new Promise((resolve6) => setTimeout(resolve6, SHORT_FLUSH_TIMEOUT_MS).unref())
         ]);
       } catch {
       }
@@ -7938,13 +8183,13 @@ function splitOptions(argv) {
   return { json, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve4(data));
+    process.stdin.on("end", () => resolve6(data));
     process.stdin.on("error", reject);
   });
 }
@@ -8139,6 +8384,289 @@ Examples:
   }
 }
 
+// ../argent-cli/src/flow.ts
+import * as fsp from "node:fs/promises";
+import * as path11 from "node:path";
+var STATUS_GLYPH = {
+  pass: "\u2713",
+  fail: "\u2717",
+  error: "\u2717",
+  skip: "\xB7"
+};
+function printHelp() {
+  console.log(`Usage: argent flow <subcommand> [options]
+
+Run a saved flow without an LLM in the loop. Flows live in
+\`.argent/flows/<name>.yaml\` under the current working directory. A flow that
+begins with a \`launch\` step runs its app from scratch; any other flow (a
+fragment) runs against the device's current state \u2014 handy while authoring one.
+
+Subcommands:
+  run <name>        Run a flow and report pass/fail (exit code reflects result)
+  list              List flows in .argent/flows
+
+Options (run):
+  --device <id>          Device id to run against (auto-detected when omitted)
+  --platform <p>         ios | android | chromium | vega \u2014 narrow auto-detection
+  --update-baselines     Write/refresh screenshot baselines instead of diffing
+  --output <dir>         Also write failed snapshot images (baseline/current/diff)
+                         under <dir>/<flow>/ \u2014 a stable path for CI artifact upload
+  --json                 Print the raw JSON report
+  --help, -h             Show this help
+
+Examples:
+  argent flow run checkout --platform ios
+  argent flow run checkout --device <UDID> --update-baselines
+  argent flow run checkout --output flow-artifacts --json
+`);
+}
+function parseRunArgs(argv) {
+  const out = { updateBaselines: false, json: false };
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const tok = argv[i2];
+    if (!tok.startsWith("-")) {
+      if (!out.name) out.name = tok;
+      continue;
+    }
+    const eq = tok.startsWith("--") ? tok.indexOf("=") : -1;
+    const flag = eq === -1 ? tok : tok.slice(0, eq);
+    const inline = eq === -1 ? void 0 : tok.slice(eq + 1);
+    const takeValue = (name) => {
+      if (inline !== void 0) {
+        if (inline === "") throw new FlagParseException(`${name} requires a value`);
+        return inline;
+      }
+      const v = argv[i2 + 1];
+      if (v === void 0 || v.startsWith("-")) {
+        throw new FlagParseException(`${name} requires a value`);
+      }
+      i2 += 1;
+      return v;
+    };
+    const noValue = (name) => {
+      if (inline !== void 0) throw new FlagParseException(`${name} does not take a value`);
+    };
+    if (flag === "--update-baselines") {
+      noValue("--update-baselines");
+      out.updateBaselines = true;
+    } else if (flag === "--json") {
+      noValue("--json");
+      out.json = true;
+    } else if (flag === "--device") out.device = takeValue("--device");
+    else if (flag === "--platform") out.platform = takeValue("--platform");
+    else if (flag === "--output") out.output = takeValue("--output");
+    else throw new FlagParseException(`unknown flag ${tok}`);
+  }
+  return out;
+}
+function renderStepLine(s, n2, topFlow) {
+  const where = s.flow && s.flow !== topFlow ? ` [${s.flow}]` : "";
+  const what = s.tool ?? s.target;
+  const label = what ? `${s.kind} ${what}` : s.kind;
+  const reason = s.reason ? ` \u2014 ${s.reason}` : "";
+  const glyph = s.status === "pass" && s.warning ? "\u26A0" : STATUS_GLYPH[s.status];
+  return `  ${glyph} ${String(n2).padStart(2)} ${label}${where}${reason}`;
+}
+function renderSummary(report, opts = {}) {
+  const warnings = report.steps.filter((s) => s.warning).length;
+  const warningsNote = warnings ? `, ${warnings} warning${warnings === 1 ? "" : "s"}` : "";
+  const where = opts.withDevice ? ` on ${report.device}` : "";
+  return `${report.ok ? "PASS" : "FAIL"}${where} \u2014 ${report.passed} passed, ${report.failed} failed, ${report.errored} errored, ${report.skipped} skipped${warningsNote}`;
+}
+function renderArtifactLines(report) {
+  const lines = [];
+  let n2 = 0;
+  for (const s of report.steps) {
+    if (s.kind === "echo") continue;
+    n2++;
+    if (!s.artifacts || typeof s.artifacts !== "object") continue;
+    const entries = Object.entries(s.artifacts).filter(([, v]) => typeof v === "string");
+    if (entries.length === 0) continue;
+    lines.push(`  ${s.kind} (step ${n2}):`);
+    for (const [k, v] of entries) lines.push(`       ${k}: ${v}`);
+  }
+  return lines;
+}
+var SAFE_ARTIFACT_NAME = /^[A-Za-z0-9_-]+$/;
+async function exportFailureArtifacts(report, outputDir, ctx) {
+  if (!SAFE_ARTIFACT_NAME.test(report.flow)) {
+    console.error(
+      `warning: skipping artifact export for unsafe flow name ${JSON.stringify(report.flow)}`
+    );
+    return;
+  }
+  for (const s of report.steps) {
+    if (s.kind !== "snapshot" || s.status !== "fail" || !s.artifacts) continue;
+    const key = s.snapshotKey ?? keyFromBaselinePath(s.artifacts);
+    if (!key || !SAFE_ARTIFACT_NAME.test(key)) continue;
+    const { result } = await materializeArtifacts(s.artifacts, ctx);
+    s.artifacts = result;
+    const dir = path11.join(outputDir, report.flow);
+    for (const [role, value] of Object.entries(s.artifacts)) {
+      if (typeof value !== "string") continue;
+      const dest = path11.join(dir, `${key}-${role}.png`);
+      const rel = path11.relative(outputDir, dest);
+      if (rel.startsWith("..") || path11.isAbsolute(rel)) continue;
+      try {
+        await fsp.mkdir(dir, { recursive: true });
+        await fsp.copyFile(value, dest);
+        s.artifacts[role] = dest;
+      } catch (err) {
+        console.error(
+          `warning: could not write ${dest}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+}
+function keyFromBaselinePath(artifacts) {
+  const baseline = artifacts.baseline;
+  if (typeof baseline !== "string") return null;
+  return path11.basename(baseline).replace(/\.png$/, "");
+}
+function resolveArtifactDisplayPaths(report) {
+  for (const s of report.steps) {
+    if (!s.artifacts || typeof s.artifacts !== "object") continue;
+    for (const [role, value] of Object.entries(s.artifacts)) {
+      if (isArtifactHandle(value)) s.artifacts[role] = value.hostPath ?? value.filename;
+    }
+  }
+}
+function exitAfterFlush(code, streams = [process.stdout, process.stderr]) {
+  return Promise.all(
+    streams.map((s) => new Promise((resolve6) => s.write("", () => resolve6())))
+  ).then(() => process.exit(code));
+}
+function renderReport(report) {
+  const lines = [];
+  lines.push(`Flow "${report.flow}" on ${report.device}`);
+  if (report.executionPrerequisite) {
+    lines.push(`  assumes: ${report.executionPrerequisite}`);
+  }
+  let n2 = 0;
+  for (const s of report.steps) {
+    if (s.kind === "echo") {
+      if (s.message) lines.push(`  \u203A ${s.message}`);
+      continue;
+    }
+    n2++;
+    lines.push(renderStepLine(s, n2, report.flow));
+    if (s.warning) lines.push(`       \u26A0 ${s.warning}`);
+    if (s.artifacts && typeof s.artifacts === "object") {
+      for (const [k, v] of Object.entries(s.artifacts)) {
+        if (typeof v === "string") lines.push(`       ${k}: ${v}`);
+      }
+    }
+  }
+  lines.push(`
+${renderSummary(report)}`);
+  return lines.join("\n");
+}
+async function flow(argv, options) {
+  const [sub, ...rest] = argv;
+  if (!sub || sub === "--help" || sub === "-h") {
+    printHelp();
+    return;
+  }
+  const { callTool, baseUrl } = createToolsClient({ paths: options.paths });
+  if (sub === "list") {
+    const dir = path11.join(process.cwd(), ".argent", "flows");
+    try {
+      const entries = await fsp.readdir(dir);
+      const names = entries.filter((f) => f.endsWith(".yaml")).map((f) => f.replace(/\.yaml$/, ""));
+      if (names.length === 0) console.log("No flows found in .argent/flows");
+      else console.log(names.join("\n"));
+    } catch {
+      console.log("No .argent/flows directory in the current working directory.");
+    }
+    return;
+  }
+  if (sub !== "run") {
+    console.error(`Unknown flow subcommand "${sub}". Run \`argent flow --help\`.`);
+    return exitAfterFlush(2);
+  }
+  if (rest.includes("--help") || rest.includes("-h")) {
+    printHelp();
+    return;
+  }
+  let args;
+  try {
+    args = parseRunArgs(rest);
+  } catch (err) {
+    if (err instanceof FlagParseException) {
+      console.error(`Error: ${err.message}
+`);
+      printHelp();
+      return exitAfterFlush(2);
+    }
+    throw err;
+  }
+  if (!args.name) {
+    console.error("argent flow run <name> requires a flow name.");
+    printHelp();
+    return exitAfterFlush(2);
+  }
+  const flowName = args.name;
+  const payload = {
+    name: flowName,
+    project_root: process.cwd(),
+    // Headless runs never block on the LLM prerequisite handshake.
+    prerequisiteAcknowledged: true
+  };
+  if (args.device) payload.device = args.device;
+  if (args.platform) payload.platform = args.platform;
+  if (args.updateBaselines) payload.updateBaselines = true;
+  let liveSteps = 0;
+  let liveIndex = 0;
+  const onStepReport = (event) => {
+    const s = event;
+    if (liveSteps === 0) console.log(`Flow "${flowName}"`);
+    liveSteps++;
+    if (s.kind === "echo") {
+      if (s.message) console.log(`  \u203A ${s.message}`);
+      return;
+    }
+    liveIndex++;
+    console.log(renderStepLine(s, liveIndex, flowName));
+    if (s.warning) console.log(`       \u26A0 ${s.warning}`);
+  };
+  let report;
+  try {
+    const resp = await callTool(
+      "flow-execute",
+      payload,
+      args.json ? void 0 : { onProgress: onStepReport }
+    );
+    report = resp.data;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return exitAfterFlush(1);
+  }
+  if (!report || !("steps" in report)) {
+    console.error(`"${flowName}" did not produce a run report.`);
+    return exitAfterFlush(2);
+  }
+  if (args.output) {
+    const { url, token } = await baseUrl();
+    await exportFailureArtifacts(report, path11.resolve(args.output), {
+      toolsUrl: url,
+      authToken: token
+    });
+  }
+  resolveArtifactDisplayPaths(report);
+  if (args.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else if (liveSteps > 0) {
+    if (report.executionPrerequisite) console.log(`  assumes: ${report.executionPrerequisite}`);
+    for (const line of renderArtifactLines(report)) console.log(line);
+    console.log(`
+${renderSummary(report, { withDevice: true })}`);
+  } else {
+    console.log(renderReport(report));
+  }
+  return exitAfterFlush(report.ok ? 0 : 1);
+}
+
 // ../argent-cli/src/tools.ts
 function summarize(description, max = 80) {
   if (!description) return "";
@@ -8218,11 +8746,11 @@ Options:
 
 // ../argent-cli/src/server.ts
 import * as fs9 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { homedir as homedir5, networkInterfaces } from "node:os";
 import { spawn as spawn3 } from "node:child_process";
-var STATE_DIR2 = path11.join(homedir5(), ".argent");
-var LOG_FILE2 = path11.join(STATE_DIR2, "tool-server.log");
+var STATE_DIR2 = path12.join(homedir5(), ".argent");
+var LOG_FILE2 = path12.join(STATE_DIR2, "tool-server.log");
 async function describeForeignServers(ownBundlePath) {
   const others = (await readAllToolsServerStates()).filter(
     ({ state: state2 }) => state2.bundlePath !== ownBundlePath && isToolsServerProcessAlive(state2.pid)
@@ -8631,7 +9159,7 @@ async function server(argv, options) {
 // ../argent-cli/src/lens.ts
 import * as fs10 from "node:fs";
 import * as os2 from "node:os";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // ../argent-cli/src/lens-terminal.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
@@ -8872,7 +9400,7 @@ function ptyInjectBeats(text2) {
   ];
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -8982,10 +9510,10 @@ function parseSseBuffer(buffer) {
   const events = [];
   let rest = normalised;
   for (; ; ) {
-    const sep3 = rest.indexOf("\n\n");
-    if (sep3 === -1) break;
-    const rawFrame = rest.slice(0, sep3);
-    rest = rest.slice(sep3 + 2);
+    const sep4 = rest.indexOf("\n\n");
+    if (sep4 === -1) break;
+    const rawFrame = rest.slice(0, sep4);
+    rest = rest.slice(sep4 + 2);
     let event = "message";
     const dataLines = [];
     for (const line of rawFrame.split("\n")) {
@@ -9093,7 +9621,7 @@ var SPAWN_GRACE_MS = 8e3;
 var DEATH_CONFIRMATIONS = 3;
 var SSE_RECONNECT_MS = 1e3;
 function sleep2(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
 async function dismissTrustPrompt(session) {
@@ -9269,7 +9797,7 @@ function parseArgs(argv) {
   }
   return { terminal, agent, help, forget };
 }
-function printHelp() {
+function printHelp2() {
   process.stdout.write(
     `Usage: argent lens [--agent <id>] [--terminal iterm|terminal]
 
@@ -9296,7 +9824,7 @@ Options:
 async function lens(argv, options) {
   const { terminal: preferred, agent: agentId, help, forget } = parseArgs(argv);
   if (help) {
-    printHelp();
+    printHelp2();
     return;
   }
   if (forget) {
@@ -9366,7 +9894,7 @@ async function lens(argv, options) {
     await endSession(baseUrl);
     process.exit(1);
   }
-  const seedFile = path12.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
+  const seedFile = path13.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
   fs10.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
   const launchCmd = agent.launch(shellQuote(process.cwd()), shellQuote(seedFile));
   const removeSeedFile = () => {
@@ -10476,7 +11004,7 @@ import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
 import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname7, join as join15 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -11445,6 +11973,7 @@ export {
   disable,
   enable,
   flags,
+  flow,
   getFlagDefinition,
   isFlagEnabled,
   lens,