@swmansion/argent 0.27.1-next.20 → 0.27.1-next.21

package/dist/mcp-server.mjs

@@ -2241,8 +2241,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize2) {
-      if (normalize2 !== false)
+    function getFullPath(resolver, id = "", normalize3) {
+      if (normalize3 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3638,7 +3638,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize2(uri, options) {
+    function normalize3(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -3905,7 +3905,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize2,
+      normalize: normalize3,
       resolve: resolve8,
       resolveComponent,
       equal,
@@ -23628,6 +23628,7 @@ function isRecord(value) {
 }
 function collectFlowRequests(doc) {
   const runTargets = /* @__PURE__ */ new Set();
+  const snapshots = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
   const visit = (steps, depth) => {
     if (!Array.isArray(steps) || depth > MAX_BLOCK_NESTING || seen.has(steps)) return;
@@ -23639,11 +23640,17 @@ function collectFlowRequests(doc) {
         const target = completeRunExtension(run);
         if (FLOW_FILE_NAME_PATTERN.test(path2.posix.basename(target))) runTargets.add(target);
       }
+      const snapshot = isRecord(step.snapshot) ? step.snapshot.name : step.snapshot;
+      if (typeof snapshot === "string" && FLOW_NAME_PATTERN.test(snapshot)) snapshots.add(snapshot);
       visit(step.steps, depth + 1);
     }
   };
   if (isRecord(doc)) visit(doc.steps, 0);
-  return { runTargets: [...runTargets] };
+  return { runTargets: [...runTargets], snapshots: [...snapshots] };
+}
+function baselineKeyFor(canonicalPath, flowName) {
+  const stem = path2.basename(canonicalPath, ".yaml");
+  return FLOW_NAME_PATTERN.test(stem) ? stem : flowName;
 }
 function flowMemberKey(anchorDir, target) {
   return `${anchorDir}\0${target}`;
@@ -24119,7 +24126,17 @@ async function getResolvedToolsUrl() {
 // ../argent-tools-client/src/file-inputs.ts
 import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
 import { createReadStream, rmSync } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import {
+  chmod as chmod3,
+  lstat,
+  mkdir as mkdir3,
+  readFile as readFile3,
+  realpath as realpath2,
+  rename as rename2,
+  rm as rm2,
+  stat as stat2,
+  writeFile as writeFile3
+} from "node:fs/promises";
 import { constants, tmpdir } from "node:os";
 import * as path4 from "node:path";
 
@@ -24428,9 +24445,61 @@ function isAllowedClientFilePath(p) {
 function isClientFileDirective2(value) {
   return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER2] === true && typeof value.path === "string" && typeof value.content === "string";
 }
-async function applyClientFileDirectives(result) {
+async function replaceFile(target, bytes, mode) {
+  const temp = path4.join(path4.dirname(target), `.baseline-${randomUUID3()}.tmp`);
+  try {
+    await writeFile3(temp, bytes, { flag: "wx" });
+    if (mode !== void 0) await chmod3(temp, mode & 511);
+    await rename2(temp, target);
+  } catch (err) {
+    await rm2(temp, { force: true });
+    throw err;
+  }
+}
+async function writeBaselineFile(file, bytes, allowedDirs) {
+  if (!path4.isAbsolute(file) || path4.normalize(file) !== file || file.split(/[\\/]/).includes("..") || !file.endsWith(".png") || !allowedDirs.includes(path4.dirname(file))) {
+    return allowedDirs.length === 0 ? "this call writes no baselines" : `${file} is not a baseline of this call (${allowedDirs.map((d) => `${d}/<name>.png`).join(", ")})`;
+  }
+  if (bytes.length > MAX_CONTENT_BYTES) {
+    return `${file}: the baseline is larger than the 32 MiB cap on a file this client writes`;
+  }
+  const dir = path4.dirname(file);
+  await mkdir3(dir, { recursive: true });
+  const link = await lstat(file).catch(() => null);
+  const real = link === null ? null : await realpath2(file).catch(() => null);
+  if (link !== null && real === null) return `${file} is a symbolic link to a missing file`;
+  if (real !== null) {
+    if (!real.endsWith(".png")) return `${file} links to a file that is not a PNG file`;
+    if (path4.dirname(real) !== await realpath2(dir)) {
+      return `${file} links outside its baseline directory`;
+    }
+  }
+  const existing = real === null ? null : await stat2(real);
+  if (existing !== null && !existing.isFile()) return `${file} is not a regular file`;
+  await replaceFile(
+    real ?? path4.join(await realpath2(dir), path4.basename(file)),
+    bytes,
+    existing?.mode
+  );
+  return null;
+}
+async function applyClientFileDirectives(result, opts = {}) {
   const written = [];
+  const failed = [];
   async function walk(value) {
+    if (isClientFileDirective2(value) && value.encoding === "base64") {
+      const error2 = await writeBaselineFile(
+        value.path,
+        Buffer.from(value.content, "base64"),
+        opts.allowedDirs ?? []
+      ).catch((err) => err instanceof Error ? err.message : String(err));
+      if (error2 !== null) {
+        failed.push({ path: value.path, error: error2 });
+        return { path: value.path, error: error2 };
+      }
+      written.push(value.path);
+      return value.path;
+    }
     if (isClientFileDirective2(value)) {
       if (!isAllowedClientFilePath(value.path)) return null;
       try {
@@ -24443,7 +24512,9 @@ async function applyClientFileDirectives(result) {
       }
     }
     if (Array.isArray(value)) {
-      return Promise.all(value.map(walk));
+      const out = [];
+      for (const item of value) out.push(await walk(item));
+      return out;
     }
     if (value && typeof value === "object") {
       const out = {};
@@ -24455,12 +24526,12 @@ async function applyClientFileDirectives(result) {
     return value;
   }
   const rewritten = await walk(result);
-  return { result: rewritten, written };
+  return { result: rewritten, written, failed };
 }
 
 // ../argent-tools-client/src/flow-files.ts
 var import_yaml = __toESM(require_dist2(), 1);
-import { readFile as readFile4, realpath as realpath2, stat as stat3 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
 import * as path5 from "node:path";
 var INLINE_MEMBERS_BYTES = 256 * 1024;
 var FLOW_FILES_LOG_ENV = "ARGENT_FLOW_FILES_LOG";
@@ -24495,7 +24566,7 @@ function savedFlowProject(file) {
 }
 async function landing(spelled) {
   try {
-    const canonical = await realpath2(spelled);
+    const canonical = await realpath3(spelled);
     return { canonical, fence: canonical };
   } catch (err) {
     const failure = err.code === "ENOENT" ? { missing: true } : { error: err.message };
@@ -24504,7 +24575,7 @@ async function landing(spelled) {
     for (; ; ) {
       const parent = path5.dirname(at);
       if (parent === at) return { canonical, fence: spelled, ...failure };
-      const real = await realpath2(parent).catch(() => null);
+      const real = await realpath3(parent).catch(() => null);
       if (real !== null) {
         return { canonical, fence: path5.join(real, path5.basename(at)), ...failure };
       }
@@ -24524,7 +24595,7 @@ async function closureRoots(rootPath, rootCanonical, projectRoot) {
   }
   const real = [];
   for (const candidate of candidates) {
-    const resolved = await realpath2(candidate).catch(() => null);
+    const resolved = await realpath3(candidate).catch(() => null);
     if (resolved !== null && !real.includes(resolved)) real.push(resolved);
   }
   return real.filter((root) => !real.some((other) => other !== root && isWithin(root, other)));
@@ -24562,31 +24633,96 @@ async function readFlowMember(anchorDir, target, roots, budget, opts) {
   if (!/\.ya?ml$/i.test(path5.basename(canonical))) {
     return refuse(`${target} links to a file that is not a YAML file`);
   }
-  const read = await readFileInputWire(canonical, { includeContent: true });
+  const sent = await sendBytes(member, canonical, budget, opts);
+  return { ...sent, text: sent.bytes?.toString("utf8") };
+}
+function callPlatform(args) {
+  if (typeof args.device === "string" && args.device.startsWith("chromium-cdp-")) return "chromium";
+  if (typeof args.platform !== "string") return void 0;
+  return args.platform === "ios-remote" ? "ios" : args.platform;
+}
+async function baselineEntry(file, roots, forWrite) {
+  const { canonical, error: error2 } = await landing(file);
+  if (!roots.some((root) => isWithin(canonical, root))) {
+    return {
+      state: "refused",
+      error: `${file} is outside every root this client serves (${roots.join(", ")})`
+    };
+  }
+  if (error2 !== void 0) return { state: "refused", error: error2 };
+  const st = await stat3(canonical).catch((err) => err);
+  if (st instanceof Error) {
+    if (st.code !== "ENOENT") return { state: "refused", error: st.message };
+    return forWrite ? { state: "refused", error: `${file} is a symbolic link to a missing file` } : { state: "missing" };
+  }
+  if (!canonical.endsWith(".png")) {
+    return { state: "refused", error: `${file} links to a file that is not a PNG file` };
+  }
+  if (forWrite && !st.isFile()) return { state: "refused", error: `${file} is not a regular file` };
+  if (st.isDirectory()) {
+    return { state: "refused", error: "EISDIR: illegal operation on a directory, read" };
+  }
+  return st.isFile() ? { state: "ok", real: canonical } : { state: "missing" };
+}
+async function sendBytes(member, real, budget, opts) {
+  const read = await readFileInputWire(real, { includeContent: true });
   if (read?.contentOmitted) {
-    return refuse(`${canonical} is larger than the 32 MiB cap on a file sent to the tool-server`);
+    const error2 = `${real} is larger than the 32 MiB cap on a file sent to the tool-server`;
+    return { member: { ...member, state: "refused", error: error2 }, sent: `refused (${error2})` };
   }
   if (read?.content === void 0) {
-    return refuse(
-      await readFile4(canonical).then(
-        () => `${canonical} could not be read on this client`,
-        (err) => err instanceof Error ? err.message : String(err)
-      )
+    const error2 = await readFile4(real).then(
+      () => `${real} could not be read on this client`,
+      (err) => err instanceof Error ? err.message : String(err)
     );
+    return { member: { ...member, state: "refused", error: error2 }, sent: `refused (${error2})` };
   }
-  const text = Buffer.from(read.content, "base64").toString("utf8");
+  const bytes = Buffer.from(read.content, "base64");
   const size = read.size ?? 0;
   if (budget.inline + size <= INLINE_MEMBERS_BYTES || !opts.uploadEndpoint) {
     budget.inline += size;
-    return { member: { ...member, ...read }, text, sent: `inline ${size}` };
+    return { member: { ...member, ...read }, sent: `inline ${size}`, bytes };
   }
-  const uploaded = await uploadFile(canonical, opts.uploadEndpoint, opts.signal);
+  const uploaded = await uploadFile(real, opts.uploadEndpoint, opts.signal);
   return {
     member: { ...member, size: read.size, mtimeMs: read.mtimeMs, ...uploaded },
-    text,
-    sent: `upload ${size}`
+    sent: `upload ${size}`,
+    bytes
   };
 }
+async function collectBaselineMembers(canonical, flowName, snapshots, args, roots, budget, opts, emit) {
+  const dir = path5.join(
+    path5.dirname(canonical),
+    "__baselines__",
+    baselineKeyFor(canonical, flowName)
+  );
+  const real = (await landing(dir)).canonical;
+  if (!roots.some((root) => isWithin(real, root))) return;
+  const updates = args.updateBaselines === true;
+  if (updates) opts.baselineDirs?.push(dir);
+  const platform = callPlatform(args);
+  const prefixes = snapshots.map(
+    (name) => `${name}__${platform === void 0 ? "" : `${platform}-`}`
+  );
+  const names = await readdir4(dir).catch(() => []);
+  for (const name of names.sort()) {
+    if (!name.endsWith(".png")) continue;
+    if (!updates && !prefixes.some((prefix) => name.startsWith(prefix))) continue;
+    const file = path5.join(dir, name);
+    const member = { role: "baseline", key: file, path: file };
+    const entry = await baselineEntry(file, roots, updates);
+    if (entry.state === "refused") {
+      emit({ ...member, state: "refused", error: entry.error }, `refused (${entry.error})`);
+    } else if (entry.state === "missing") {
+      emit({ ...member, state: "missing" }, "missing");
+    } else if (updates) {
+      emit({ ...member, state: "listed" }, "listed");
+    } else {
+      const sent = await sendBytes(member, entry.real, budget, opts);
+      emit(sent.member, sent.sent);
+    }
+  }
+}
 async function collectFlowMembers(rootPath, rootBytes, args, opts) {
   if (!namesValidFlow(args)) return {};
   const canonical = await canonicalFlowPath(rootPath);
@@ -24598,10 +24734,16 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
   const roots = await closureRoots(rootPath, canonical, args.project_root);
   const members = [];
   const seen = /* @__PURE__ */ new Set();
+  const snapshots = /* @__PURE__ */ new Set();
   const budget = { inline: 0 };
   const logging = process.env[FLOW_FILES_LOG_ENV] === "1";
   const log = opts.log ?? ((line) => void process.stderr.write(`${line}
 `));
+  const emit = (member, sent) => {
+    members.push(member);
+    const subject = member.role === "flow" ? member.canonical : member.key;
+    if (logging) log(printable(`[flow-files] ${member.role} ${subject}: ${sent}`));
+  };
   const queue = [{ canonical, text: rootBytes.toString("utf8"), hop: 0 }];
   for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
     let doc;
@@ -24610,19 +24752,33 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
     } catch {
       continue;
     }
+    const requests = collectFlowRequests(doc);
+    for (const name of requests.snapshots) snapshots.add(name);
     const anchorDir = path5.dirname(file.canonical);
-    for (const target of collectFlowRequests(doc).runTargets) {
+    for (const target of requests.runTargets) {
       const key = flowMemberKey(anchorDir, target);
       if (seen.has(key)) continue;
       seen.add(key);
       const { member, text, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
-      members.push(member);
-      if (logging) log(printable(`[flow-files] flow ${member.canonical}: ${sent}`));
+      emit(member, sent);
       if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
         queue.push({ canonical: member.canonical, text, hop: file.hop + 1 });
       }
     }
   }
+  if (snapshots.size > 0) {
+    const flowName = path5.basename(rootPath, ".yaml");
+    await collectBaselineMembers(
+      canonical,
+      flowName,
+      [...snapshots],
+      args,
+      roots,
+      budget,
+      opts,
+      emit
+    );
+  }
   return { canonical, spelling, members };
 }
 
@@ -24657,7 +24813,20 @@ async function consumeToolStream(name, body, onProgress, signal) {
     }
   };
   const decoder = new TextDecoder();
-  let buffered = "";
+  let pieces = [];
+  const take = (text) => {
+    let start = 0;
+    let newline;
+    while ((newline = text.indexOf("\n", start)) !== -1) {
+      signal?.throwIfAborted();
+      pieces.push(text.slice(start, newline));
+      const line = pieces.join("");
+      pieces = [];
+      start = newline + 1;
+      handleLine(line);
+    }
+    if (start < text.length) pieces.push(text.slice(start));
+  };
   try {
     for (; ; ) {
       let chunk;
@@ -24669,17 +24838,11 @@ async function consumeToolStream(name, body, onProgress, signal) {
       }
       const { done, value } = chunk;
       if (done) break;
-      buffered += decoder.decode(value, { stream: true });
-      let newline;
-      while ((newline = buffered.indexOf("\n")) !== -1) {
-        signal?.throwIfAborted();
-        const line = buffered.slice(0, newline);
-        buffered = buffered.slice(newline + 1);
-        handleLine(line);
-      }
+      take(decoder.decode(value, { stream: true }));
     }
-    buffered += decoder.decode();
-    if (buffered.trim()) handleLine(buffered);
+    take(decoder.decode());
+    const last = pieces.join("");
+    if (last.trim()) handleLine(last);
   } catch (err) {
     void reader.cancel().catch(() => {
     });
@@ -24689,8 +24852,7 @@ async function consumeToolStream(name, body, onProgress, signal) {
   if (!final) {
     throw brokenStream(name, "the stream ended without a result", progress);
   }
-  const { result: data } = await applyClientFileDirectives(final.data);
-  return { data, note: final.note };
+  return { data: final.data, note: final.note };
 }
 function errorBodyMessage(body) {
   if (Array.isArray(body.issues) && typeof body.message === "string") return body.message;
@@ -24779,16 +24941,28 @@ function createToolsClient(options = {}) {
     const { url, token, remote } = await route();
     let finalArgs = args;
     const meta2 = await fetchTool(name, { signal: opts?.signal });
+    const baselineDirs = [];
     if (meta2?.fileInputs?.length) {
       if (remote) assertRequiredPresent(meta2, args);
       finalArgs = await prepareFileInputs(meta2.fileInputs, args ?? {}, {
         includeContent: remote,
         uploadEndpoint: remote ? { url, token } : void 0,
         log: diagnose,
+        baselineDirs,
         collectMembers: collectFlowMembers,
         signal: opts?.signal
       });
     }
+    const settle = async (data) => {
+      const applied = await applyClientFileDirectives(data, { allowedDirs: baselineDirs });
+      for (const { path: file, error: error2 } of applied.failed) {
+        diagnose(`The baseline ${file} was not written on this client: ${error2}`);
+      }
+      if (process.env.ARGENT_FLOW_FILES_LOG === "1") {
+        for (const file of applied.written) diagnose(`[flow-files] baseline ${file}: written`);
+      }
+      return applied.result;
+    };
     const stream = opts?.onProgress !== void 0 || carriesMembers(finalArgs);
     const sentOnce = carriesUpload(finalArgs);
     const res = await doFetch(
@@ -24820,7 +24994,11 @@ function createToolsClient(options = {}) {
         }),
         opts?.signal
       );
-      return { ...streamed, outputHint: meta2?.outputHint };
+      return {
+        data: await settle(streamed.data),
+        note: streamed.note,
+        outputHint: meta2?.outputHint
+      };
     }
     let json;
     try {
@@ -24844,17 +25022,16 @@ function createToolsClient(options = {}) {
       });
     }
     opts?.signal?.throwIfAborted();
-    const { result: data } = await applyClientFileDirectives(json.data);
-    return { data, note: json.note, outputHint: meta2?.outputHint };
+    return { data: await settle(json.data), note: json.note, outputHint: meta2?.outputHint };
   }
   return { fetchTools, fetchTool, callTool, baseUrl };
 }
 
 // ../argent-tools-client/src/artifacts.ts
-import { copyFile, mkdir as mkdir4, readFile as readFile5, realpath as realpath3, rm as rm3, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir4, readFile as readFile5, realpath as realpath4, rm as rm3, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename6, dirname as dirname7, extname as extname2, isAbsolute as isAbsolute5, join as join11, normalize, resolve as resolve6, sep as sep4 } from "node:path";
+import { basename as basename6, dirname as dirname7, extname as extname2, isAbsolute as isAbsolute5, join as join11, normalize as normalize2, resolve as resolve6, sep as sep4 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 
 // ../configuration-core/src/flags.ts
@@ -25298,8 +25475,8 @@ function durableBaseDir() {
   const projectRoot = findProjectRoot(process.cwd());
   return projectRoot ?? dirname7(argentHomeDir());
 }
-var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize(".argent/recordings")]);
-var RECORDINGS_SAVE_DIR = normalize(".argent/recordings");
+var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize2(".argent/recordings")]);
+var RECORDINGS_SAVE_DIR = normalize2(".argent/recordings");
 function configuredRecordingsDir() {
   let value;
   try {
@@ -25358,7 +25535,7 @@ async function writeDurableUnique(dir, filename, write) {
 }
 function durableSaveTarget(handle) {
   if (typeof handle.saveDir !== "string" || !handle.saveDir || handle.archive) return null;
-  const rel = normalize(handle.saveDir);
+  const rel = normalize2(handle.saveDir);
   if (isAbsolute5(rel) || rel === ".." || rel.startsWith(`..${sep4}`) || rel.split(sep4).includes("..")) {
     return null;
   }
@@ -25380,8 +25557,8 @@ function durableSaveTarget(handle) {
 }
 async function confineToRealBase(dir, base, rel) {
   try {
-    const realDir = await realpath3(dir);
-    const realBase = await realpath3(base);
+    const realDir = await realpath4(dir);
+    const realBase = await realpath4(base);
     return realDir === join11(realBase, rel);
   } catch {
     return false;
@@ -26534,6 +26711,12 @@ async function flowRunToMcpContent(result, ctx) {
       blocks.push(...await stepArtifactBlocks(step.artifacts, step.status, ctx, step.depth));
     }
   }
+  for (const write of result.baselineWrites ?? []) {
+    const { path: path15, error: error2 } = isRecord2(write) ? write : {};
+    if (typeof path15 === "string" && typeof error2 === "string") {
+      blocks.push({ type: "text", text: `\u2717 baseline not written: ${path15}: ${error2}` });
+    }
+  }
   if (result.ok !== void 0) {
     const counted = (result.passed ?? 0) + (result.failed ?? 0) + (result.errored ?? 0) + (result.skipped ?? 0);
     const note = result.ok && counted === 0 ? " (no test steps)" : "";

package/dist/tool-args.generated.d.ts

@@ -225,7 +225,7 @@ export interface ArgentToolArgs {
         project_root: string;
         /** Path to the flow .yaml as readable by the tool-server. Internal — the argent client derives it from project_root and name automatically; leave unset. */
         flow_file?: string;
-        /** Omit when name is set. Absolute path to a flow .yaml on the client. Over a link (argent link or ARGENT_TOOLS_URL), the argent client uploads the file and its run: fragments, and the tool-server runs those copies. Keep run: fragments under project_root or beside the flow file. Over a link, the flow and its fragments must not have script: or snapshot: steps, or tool: steps that take a file or record a flow. Without a link, the tool-server reads the files in place and all step kinds run. */
+        /** Omit when name is set. Absolute path to a flow .yaml on the client. Over a link (argent link or ARGENT_TOOLS_URL), the argent client uploads the file, its run: fragments and the snapshot baselines that the run compares, and the tool-server runs those copies. Keep run: fragments under project_root or beside the flow file. With updateBaselines, the client writes the new baselines when the run ends. Over a link, the flow and its fragments must not have script: steps, or tool: steps that take a file or record a flow. Without a link, the tool-server reads the files in place and all step kinds run. */
         flow_path?: string;
         /** Device id to run against (iOS UDID, Android/Vega serial, Chromium id) — the id list-devices reports. Auto-detected when omitted, but only when exactly one booted device matches (optionally narrowed by `platform`); with several booted the run fails and lists them, so pass this explicitly whenever more than one device is up. */
         device?: string;