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

package/dist/client.js

@@ -8593,6 +8593,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;
@@ -8604,11 +8605,17 @@ function collectFlowRequests(doc) {
         const target = completeRunExtension(run);
         if (FLOW_FILE_NAME_PATTERN.test(path7.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 = path7.basename(canonicalPath, ".yaml");
+  return FLOW_NAME_PATTERN.test(stem) ? stem : flowName;
 }
 function flowMemberKey(anchorDir, target) {
   return `${anchorDir}\0${target}`;
@@ -9045,7 +9052,17 @@ async function getResolvedToolsUrl() {
 // ../argent-tools-client/src/file-inputs.ts
 import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
 import { createReadStream, rmSync as rmSync2 } 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 path9 from "node:path";
 
@@ -9354,9 +9371,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 = path9.join(path9.dirname(target), `.baseline-${randomUUID4()}.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 (!path9.isAbsolute(file) || path9.normalize(file) !== file || file.split(/[\\/]/).includes("..") || !file.endsWith(".png") || !allowedDirs.includes(path9.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 = path9.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 (path9.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 ?? path9.join(await realpath2(dir), path9.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 error = await writeBaselineFile(
+        value.path,
+        Buffer.from(value.content, "base64"),
+        opts.allowedDirs ?? []
+      ).catch((err) => err instanceof Error ? err.message : String(err));
+      if (error !== null) {
+        failed.push({ path: value.path, error });
+        return { path: value.path, error };
+      }
+      written.push(value.path);
+      return value.path;
+    }
     if (isClientFileDirective2(value)) {
       if (!isAllowedClientFilePath(value.path)) return null;
       try {
@@ -9369,7 +9438,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 = {};
@@ -9381,12 +9452,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_dist(), 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 path10 from "node:path";
 var INLINE_MEMBERS_BYTES = 256 * 1024;
 var FLOW_FILES_LOG_ENV = "ARGENT_FLOW_FILES_LOG";
@@ -9421,7 +9492,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 };
@@ -9430,7 +9501,7 @@ async function landing(spelled) {
     for (; ; ) {
       const parent = path10.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: path10.join(real, path10.basename(at)), ...failure };
       }
@@ -9450,7 +9521,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)));
@@ -9488,31 +9559,96 @@ async function readFlowMember(anchorDir, target, roots, budget, opts) {
   if (!/\.ya?ml$/i.test(path10.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 } = 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 (error !== void 0) return { state: "refused", error };
+  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 error = `${real} is larger than the 32 MiB cap on a file sent to the tool-server`;
+    return { member: { ...member, state: "refused", error }, sent: `refused (${error})` };
   }
   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 error = 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 }, sent: `refused (${error})` };
   }
-  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 = path10.join(
+    path10.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 = path10.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);
@@ -9524,10 +9660,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;
@@ -9536,19 +9678,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 = path10.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 = path10.basename(rootPath, ".yaml");
+    await collectBaselineMembers(
+      canonical,
+      flowName,
+      [...snapshots],
+      args,
+      roots,
+      budget,
+      opts,
+      emit
+    );
+  }
   return { canonical, spelling, members };
 }
 
@@ -9583,7 +9739,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;
@@ -9595,17 +9764,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(() => {
     });
@@ -9615,8 +9778,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;
@@ -9705,16 +9867,28 @@ function createToolsClient(options = {}) {
     const { url, token, remote } = await route();
     let finalArgs = args;
     const meta = await fetchTool(name, { signal: opts?.signal });
+    const baselineDirs = [];
     if (meta?.fileInputs?.length) {
       if (remote) assertRequiredPresent(meta, args);
       finalArgs = await prepareFileInputs(meta.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 } of applied.failed) {
+        diagnose(`The baseline ${file} was not written on this client: ${error}`);
+      }
+      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(
@@ -9746,7 +9920,11 @@ function createToolsClient(options = {}) {
         }),
         opts?.signal
       );
-      return { ...streamed, outputHint: meta?.outputHint };
+      return {
+        data: await settle(streamed.data),
+        note: streamed.note,
+        outputHint: meta?.outputHint
+      };
     }
     let json;
     try {
@@ -9770,17 +9948,16 @@ function createToolsClient(options = {}) {
       });
     }
     opts?.signal?.throwIfAborted();
-    const { result: data } = await applyClientFileDirectives(json.data);
-    return { data, note: json.note, outputHint: meta?.outputHint };
+    return { data: await settle(json.data), note: json.note, outputHint: meta?.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";
 var ARTIFACT_MARKER2 = "__argentArtifact";
 function isArtifactHandle(value) {
@@ -9815,8 +9992,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 {
@@ -9875,7 +10052,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;
   }
@@ -9897,8 +10074,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;

package/dist/installer.mjs

@@ -16736,7 +16736,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = randomUUID4();
 function readCliVersion() {
   if (true) {
-    return "0.27.1-next.20";
+    return "0.27.1-next.21";
   }
   return "0.0.0";
 }
@@ -23323,7 +23323,17 @@ var LINK_FILE = path20.join(LINK_DIR, "link.json");
 // ../argent-tools-client/src/file-inputs.ts
 import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
 import { createReadStream, rmSync as rmSync6 } 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 path21 from "node:path";
 
@@ -23339,18 +23349,18 @@ var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
 
 // ../argent-tools-client/src/flow-files.ts
 var import_yaml3 = __toESM(require_dist(), 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 path22 from "node:path";
 var INLINE_MEMBERS_BYTES = 256 * 1024;
 
 // ../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 dirname15, extname as extname2, isAbsolute as isAbsolute7, join as join23, normalize, resolve as resolve13, sep as sep6 } from "node:path";
+import { basename as basename6, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute7, join as join23, normalize as normalize2, resolve as resolve13, sep as sep6 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
-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");
 var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
 
 // ../argent-installer/src/update.ts