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

package/dist/client.js

@@ -39,7 +39,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_main = __commonJS({
   "../../node_modules/dotenv/lib/main.js"(exports, module) {
     var fs7 = __require("fs");
-    var path12 = __require("path");
+    var path13 = __require("path");
     var os2 = __require("os");
     var crypto2 = __require("crypto");
     var TIPS = [
@@ -178,7 +178,7 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path12.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path13.resolve(process.cwd(), ".env.vault");
       }
       if (fs7.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
@@ -186,7 +186,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path12.join(os2.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path13.join(os2.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -203,7 +203,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path12.resolve(process.cwd(), ".env");
+      const dotenvPath = path13.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -231,13 +231,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path13 of optionPaths) {
+      for (const path14 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs7.readFileSync(path13, { encoding }));
+          const parsed = DotenvModule.parse(fs7.readFileSync(path14, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`failed to load ${path13} ${e.message}`);
+            _debug(`failed to load ${path14} ${e.message}`);
           }
           lastError = e;
         }
@@ -250,7 +250,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative2 = path12.relative(process.cwd(), filePath);
+            const relative2 = path13.relative(process.cwd(), filePath);
             shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
@@ -431,17 +431,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path12) {
-      const ctrl = callVisitor(key, node, visitor, path12);
+    function visit_(key, node, visitor, path13) {
+      const ctrl = callVisitor(key, node, visitor, path13);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visit_(key, ctrl, visitor, path12);
+        replaceNode(key, path13, ctrl);
+        return visit_(key, ctrl, visitor, path13);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path13 = Object.freeze(path13.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path12);
+            const ci = visit_(i, node.items[i], visitor, path13);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -452,13 +452,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = visit_("key", node.key, visitor, path12);
+          path13 = Object.freeze(path13.concat(node));
+          const ck = visit_("key", node.key, visitor, path13);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path12);
+          const cv = visit_("value", node.value, visitor, path13);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -479,17 +479,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path12) {
-      const ctrl = await callVisitor(key, node, visitor, path12);
+    async function visitAsync_(key, node, visitor, path13) {
+      const ctrl = await callVisitor(key, node, visitor, path13);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visitAsync_(key, ctrl, visitor, path12);
+        replaceNode(key, path13, ctrl);
+        return visitAsync_(key, ctrl, visitor, path13);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path13 = Object.freeze(path13.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path12);
+            const ci = await visitAsync_(i, node.items[i], visitor, path13);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -500,13 +500,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path12);
+          path13 = Object.freeze(path13.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path13);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path12);
+          const cv = await visitAsync_("value", node.value, visitor, path13);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -533,23 +533,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path12) {
+    function callVisitor(key, node, visitor, path13) {
       if (typeof visitor === "function")
-        return visitor(key, node, path12);
+        return visitor(key, node, path13);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path12);
+        return visitor.Map?.(key, node, path13);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path12);
+        return visitor.Seq?.(key, node, path13);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path12);
+        return visitor.Pair?.(key, node, path13);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path12);
+        return visitor.Scalar?.(key, node, path13);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path12);
+        return visitor.Alias?.(key, node, path13);
       return void 0;
     }
-    function replaceNode(key, path12, node) {
-      const parent = path12[path12.length - 1];
+    function replaceNode(key, path13, node) {
+      const parent = path13[path13.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -1159,10 +1159,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path12, value) {
+    function collectionFromPath(schema, path13, value) {
       let v = value;
-      for (let i = path12.length - 1; i >= 0; --i) {
-        const k = path12[i];
+      for (let i = path13.length - 1; i >= 0; --i) {
+        const k = path13[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -1181,7 +1181,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[Symbol.iterator]().next().done;
+    var isEmptyPath = (path13) => path13 == null || typeof path13 === "object" && !!path13[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -1211,11 +1211,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path12, value) {
-        if (isEmptyPath(path12))
+      addIn(path13, value) {
+        if (isEmptyPath(path13))
           this.add(value);
         else {
-          const [key, ...rest] = path12;
+          const [key, ...rest] = path13;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -1229,8 +1229,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        const [key, ...rest] = path12;
+      deleteIn(path13) {
+        const [key, ...rest] = path13;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -1244,8 +1244,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        const [key, ...rest] = path12;
+      getIn(path13, keepScalar) {
+        const [key, ...rest] = path13;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1263,8 +1263,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path12) {
-        const [key, ...rest] = path12;
+      hasIn(path13) {
+        const [key, ...rest] = path13;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -1274,8 +1274,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        const [key, ...rest] = path12;
+      setIn(path13, value) {
+        const [key, ...rest] = path13;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3790,9 +3790,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path12, value) {
+      addIn(path13, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path12, value);
+          this.contents.addIn(path13, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3867,14 +3867,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        if (Collection.isEmptyPath(path12)) {
+      deleteIn(path13) {
+        if (Collection.isEmptyPath(path13)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path13) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3889,10 +3889,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        if (Collection.isEmptyPath(path12))
+      getIn(path13, keepScalar) {
+        if (Collection.isEmptyPath(path13))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path13, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3903,10 +3903,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path12) {
-        if (Collection.isEmptyPath(path12))
+      hasIn(path13) {
+        if (Collection.isEmptyPath(path13))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path13) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3923,13 +3923,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        if (Collection.isEmptyPath(path12)) {
+      setIn(path13, value) {
+        if (Collection.isEmptyPath(path13)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path13), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path12, value);
+          this.contents.setIn(path13, value);
         }
       }
       /**
@@ -5889,9 +5889,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path12) => {
+    visit.itemAtPath = (cst, path13) => {
       let item = cst;
-      for (const [field, index] of path12) {
+      for (const [field, index] of path13) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5900,23 +5900,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path12) => {
-      const parent = visit.itemAtPath(cst, path12.slice(0, -1));
-      const field = path12[path12.length - 1][0];
+    visit.parentCollection = (cst, path13) => {
+      const parent = visit.itemAtPath(cst, path13.slice(0, -1));
+      const field = path13[path13.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path12, item, visitor) {
-      let ctrl = visitor(item, path12);
+    function _visit(path13, item, visitor) {
+      let ctrl = visitor(item, path13);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path12.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path13.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5927,10 +5927,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path12);
+            ctrl = ctrl(item, path13);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path13) : ctrl;
     }
     exports.visit = visit;
   }
@@ -8097,7 +8097,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -8108,7 +8108,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve7(port);
+        else resolve8(port);
       });
     });
     srv.on("error", reject);
@@ -8206,7 +8206,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     let logFd;
     try {
       fs4.mkdirSync(STATE_DIR, { recursive: true });
@@ -8252,7 +8252,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve7({ port: actualPort, pid }));
+        settle(() => resolve8({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -8556,6 +8556,12 @@ async function ensureToolsServer(paths) {
   }
 }
 
+// ../argent-tools-client/src/tools-client.ts
+import * as path11 from "node:path";
+
+// ../registry/src/types.ts
+var LINKED_CALL_HEADER = "x-argent-linked";
+
 // ../registry/src/artifacts.ts
 import { stat } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -8566,6 +8572,35 @@ var FLOW_NAME_CHARSET = "[A-Za-z0-9_-]+";
 var FLOW_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}$`);
 var FLOW_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.yaml$`);
 var SCRIPT_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.mjs$`);
+function interpolateFileInputPath(template, args) {
+  let missing = false;
+  const out = template.replace(/\$\{([A-Za-z0-9_]+)\}/g, (_m, name) => {
+    const v = args[name];
+    if (typeof v !== "string" || v.length === 0) {
+      missing = true;
+      return "";
+    }
+    return v;
+  });
+  return missing ? null : out;
+}
+var TOOL_FILE_EXTENSIONS = [".png", ".yaml"];
+function hasToolFileExtension(file) {
+  const name = file.toLowerCase();
+  return TOOL_FILE_EXTENSIONS.some((extension) => name.endsWith(extension));
+}
+function toolStepFiles(specs, args) {
+  const files = [];
+  for (const spec of specs ?? []) {
+    if (spec.skipWhenSet !== void 0 && args[spec.skipWhenSet] !== void 0) continue;
+    const filled = interpolateFileInputPath(spec.path, args);
+    if (filled !== null) files.push({ spec, path: filled });
+  }
+  return files;
+}
+function isClientFileArgument({ spec, path: path13 }) {
+  return spec.kind === "file" && spec.path === `\${${spec.target}}` && path13.startsWith("/") && hasToolFileExtension(path13);
+}
 
 // ../registry/src/flow-file-refs.ts
 import * as fs5 from "node:fs/promises";
@@ -8594,6 +8629,8 @@ function isRecord(value) {
 function collectFlowRequests(doc) {
   const runTargets = /* @__PURE__ */ new Set();
   const snapshots = /* @__PURE__ */ new Set();
+  const toolSteps = [];
+  const nested = [];
   const seen = /* @__PURE__ */ new Set();
   const visit = (steps, depth) => {
     if (!Array.isArray(steps) || depth > MAX_BLOCK_NESTING || seen.has(steps)) return;
@@ -8607,11 +8644,17 @@ function collectFlowRequests(doc) {
       }
       const snapshot = isRecord(step.snapshot) ? step.snapshot.name : step.snapshot;
       if (typeof snapshot === "string" && FLOW_NAME_PATTERN.test(snapshot)) snapshots.add(snapshot);
+      if (typeof step.tool === "string") {
+        const args = isRecord(step.args) ? step.args : {};
+        toolSteps.push({ tool: step.tool, args });
+        const target = step.tool === "flow-execute" ? nestedFlowTarget(args) : void 0;
+        if (target !== void 0) nested.push({ target, args });
+      }
       visit(step.steps, depth + 1);
     }
   };
   if (isRecord(doc)) visit(doc.steps, 0);
-  return { runTargets: [...runTargets], snapshots: [...snapshots] };
+  return { runTargets: [...runTargets], snapshots: [...snapshots], toolSteps, nested };
 }
 function baselineKeyFor(canonicalPath, flowName) {
   const stem = path7.basename(canonicalPath, ".yaml");
@@ -8627,6 +8670,26 @@ async function classifyOnDiskSpelling(dir, base, addressable = FLOW_FILE_NAME_PA
   if (actual === void 0) return { state: "absent" };
   return { state: "case_folded", actual, addressable: addressable.test(actual) };
 }
+function nestedFlowTarget(args) {
+  if (typeof args !== "object" || args === null || Array.isArray(args)) return void 0;
+  const { name, project_root: projectRoot, flow_path: flowPath } = args;
+  if (flowPath === void 0) {
+    if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name)) return void 0;
+    if (!isResolvedAbsolute(projectRoot)) return void 0;
+    return {
+      kind: "name",
+      projectRoot,
+      name,
+      path: path7.join(projectRoot, ".argent", "flows", `${name}.yaml`)
+    };
+  }
+  if (name !== void 0 || !isResolvedAbsolute(flowPath)) return void 0;
+  if (!FLOW_FILE_NAME_PATTERN.test(path7.basename(flowPath))) return void 0;
+  return { kind: "flow_path", path: flowPath };
+}
+function isResolvedAbsolute(value) {
+  return typeof value === "string" && path7.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
+}
 
 // ../registry/src/failure-codes.ts
 var FAILURE_CODES = {
@@ -8947,9 +9010,9 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 var resolvedDuringInvocation = new AsyncLocalStorage();
-function valueAtPath(root, path12) {
+function valueAtPath(root, path13) {
   let current = root;
-  for (const key of path12) {
+  for (const key of path13) {
     if (current === null || typeof current !== "object") return void 0;
     if (!Object.hasOwn(current, key)) return void 0;
     current = current[key];
@@ -9233,9 +9296,9 @@ function untrackArchive(archive) {
   process.removeListener("exit", removePendingArchives);
 }
 function sha256File(filePath) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const hash = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve7(hash.digest("hex"))).on("error", reject);
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve8(hash.digest("hex"))).on("error", reject);
   });
 }
 function toolServerError(text) {
@@ -9343,6 +9406,9 @@ async function prepareFileInputs(specs, args, opts) {
         );
       }
     }
+    if (spec.kind === "probe" && spec.collect === "step" && opts.includeContent && opts.collectStepMembers) {
+      wire.members = await opts.collectStepMembers(record, opts);
+    }
     if (spec.kind === "tar-upload") {
       const st = await stat2(filePath).catch(() => null);
       if (st) {
@@ -9469,14 +9535,14 @@ function printable(text) {
     (c) => c < " " || c === "\x7F" ? `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}` : c
   ).join("");
 }
-function isResolvedAbsolute(value) {
+function isResolvedAbsolute2(value) {
   return typeof value === "string" && path10.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
 }
 function namesValidFlow(args) {
   const { project_root, flow_path, name } = args;
-  if (!isResolvedAbsolute(project_root)) return false;
+  if (!isResolvedAbsolute2(project_root)) return false;
   if (name === void 0) {
-    return isResolvedAbsolute(flow_path) && FLOW_FILE_NAME_PATTERN.test(path10.basename(flow_path));
+    return isResolvedAbsolute2(flow_path) && FLOW_FILE_NAME_PATTERN.test(path10.basename(flow_path));
   }
   return flow_path === void 0 && typeof name === "string" && FLOW_NAME_PATTERN.test(name);
 }
@@ -9562,6 +9628,29 @@ async function readFlowMember(anchorDir, target, roots, budget, opts) {
   const sent = await sendBytes(member, canonical, budget, opts);
   return { ...sent, text: sent.bytes?.toString("utf8") };
 }
+async function readToolMember(file, roots, budget, opts) {
+  const member = { role: "tool", key: file, path: file };
+  const refuse = (reason) => ({
+    member: { ...member, state: "refused", error: reason },
+    sent: `refused (${reason})`
+  });
+  const { canonical } = await landing(file);
+  if (!roots.some((root) => isWithin(canonical, root))) {
+    return refuse(`${file} is outside every root this client serves (${roots.join(", ")})`);
+  }
+  if (!hasToolFileExtension(canonical)) {
+    return refuse(`${file} links to a file that is not one of ${TOOL_FILE_EXTENSIONS.join(", ")}`);
+  }
+  const st = await stat3(canonical).catch((err) => err);
+  if (st instanceof Error) {
+    if (st.code === "ENOENT" || st.code === "ENOTDIR") {
+      return { member: { ...member, state: "missing" }, sent: "missing" };
+    }
+    return refuse(st.message);
+  }
+  if (st.isDirectory()) return refuse("EISDIR: illegal operation on a directory, read");
+  return sendBytes(member, canonical, budget, opts);
+}
 function callPlatform(args) {
   if (typeof args.device === "string" && args.device.startsWith("chromium-cdp-")) return "chromium";
   if (typeof args.platform !== "string") return void 0;
@@ -9616,51 +9705,15 @@ async function sendBytes(member, real, budget, opts) {
     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);
-    }
-  }
+function nestedRunUpdates(parentUpdates, args) {
+  return args.updateBaselines === true || parentUpdates && args.updateBaselines === void 0;
 }
-async function collectFlowMembers(rootPath, rootBytes, args, opts) {
-  if (!namesValidFlow(args)) return {};
-  const canonical = await canonicalFlowPath(rootPath);
-  const spelling = await classifyOnDiskSpelling(
-    path10.dirname(rootPath),
-    path10.basename(rootPath),
-    FLOW_FILE_NAME_PATTERN
-  );
-  const roots = await closureRoots(rootPath, canonical, args.project_root);
+function memberCollector(roots, opts) {
   const members = [];
-  const seen = /* @__PURE__ */ new Set();
-  const snapshots = /* @__PURE__ */ new Set();
+  const flows = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Set();
+  const runs = /* @__PURE__ */ new Set();
+  const baselineDirs = /* @__PURE__ */ new Map();
   const budget = { inline: 0 };
   const logging = process.env[FLOW_FILES_LOG_ENV] === "1";
   const log = opts.log ?? ((line) => void process.stderr.write(`${line}
@@ -9670,42 +9723,194 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
     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;
-    try {
-      doc = (0, import_yaml.parse)(file.text.trim(), { logLevel: "error" });
-    } 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 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);
-      emit(member, sent);
-      if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
-        queue.push({ canonical: member.canonical, text, hop: file.hop + 1 });
+  async function flow(anchorDir, target) {
+    const key = flowMemberKey(anchorDir, target);
+    const known = flows.get(key);
+    if (known !== void 0) return known;
+    const { member, text, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
+    const entry = { member, ...text === void 0 ? {} : { text } };
+    flows.set(key, entry);
+    emit(member, sent);
+    return entry;
+  }
+  async function toolFiles(step) {
+    if (step.tool === "flow-execute") return;
+    for (const file of toolStepFiles(opts.toolFileInputs?.(step.tool), step.args)) {
+      const { unwrapWhenSet } = file.spec;
+      if (unwrapWhenSet !== void 0 && step.args[unwrapWhenSet] !== void 0) continue;
+      if (!isClientFileArgument(file) || tools.has(file.path)) continue;
+      tools.add(file.path);
+      const read = await readToolMember(file.path, roots, budget, opts);
+      emit(read.member, read.sent);
+    }
+  }
+  async function nestedRun(target, hop, updates, platform) {
+    const { member, text } = await flow(path10.dirname(target.path), `${target.name}.yaml`);
+    if (text === void 0 || hop >= MAX_RUN_DEPTH) return void 0;
+    return { canonical: member.canonical, text, flowName: target.name, hop, updates, platform };
+  }
+  async function walk(start) {
+    const queue = [...start];
+    for (let run = queue.shift(); run !== void 0; run = queue.shift()) {
+      const id = [run.canonical, run.flowName, run.updates, run.platform ?? ""].join("\0");
+      if (runs.has(id)) continue;
+      runs.add(id);
+      const snapshots = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new Set();
+      const files = [{ canonical: run.canonical, text: run.text, hop: run.hop }];
+      for (let file = files.shift(); file !== void 0; file = files.shift()) {
+        let doc;
+        try {
+          doc = (0, import_yaml.parse)(file.text.trim(), { logLevel: "error" });
+        } catch {
+          continue;
+        }
+        const requests = collectFlowRequests(doc);
+        for (const name of requests.snapshots) snapshots.add(name);
+        for (const step of requests.toolSteps) await toolFiles(step);
+        const anchorDir = path10.dirname(file.canonical);
+        for (const target of requests.runTargets) {
+          const key = flowMemberKey(anchorDir, target);
+          if (visited.has(key)) continue;
+          visited.add(key);
+          const { member, text } = await flow(anchorDir, target);
+          if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
+            files.push({ canonical: member.canonical, text, hop: file.hop + 1 });
+          }
+        }
+        for (const { target, args } of requests.nested) {
+          if (target.kind !== "name") continue;
+          const next = await nestedRun(
+            target,
+            file.hop + 1,
+            nestedRunUpdates(run.updates, args),
+            run.platform
+          );
+          if (next !== void 0) queue.push(next);
+        }
+      }
+      if (snapshots.size === 0) continue;
+      const dir = path10.join(
+        path10.dirname(run.canonical),
+        "__baselines__",
+        baselineKeyFor(run.canonical, run.flowName)
+      );
+      const entry = baselineDirs.get(dir) ?? { prefixes: /* @__PURE__ */ new Set(), updates: false };
+      baselineDirs.set(dir, entry);
+      if (run.updates) {
+        entry.updates = true;
+      } else {
+        const platform = run.platform === void 0 ? "" : `${run.platform}-`;
+        for (const name of snapshots) entry.prefixes.add(`${name}__${platform}`);
+      }
+    }
+  }
+  async function sendBaselines() {
+    for (const [dir, { prefixes, updates }] of baselineDirs) {
+      const real = (await landing(dir)).canonical;
+      if (!roots.some((root) => isWithin(real, root))) continue;
+      if (updates) opts.baselineDirs?.push(dir);
+      const names = await readdir4(dir).catch(() => []);
+      for (const name of names.sort()) {
+        if (!name.endsWith(".png")) continue;
+        const compared = [...prefixes].some((prefix) => name.startsWith(prefix));
+        if (!updates && !compared) continue;
+        const file = path10.join(dir, name);
+        if (tools.has(file)) continue;
+        const member = { role: "baseline", key: file, path: file };
+        const entry = await baselineEntry(file, roots, updates && !compared);
+        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 (!compared) {
+          emit({ ...member, state: "listed" }, "listed");
+        } else {
+          const sent = await sendBytes(member, entry.real, budget, opts);
+          emit(sent.member, sent.sent);
+        }
       }
     }
   }
-  if (snapshots.size > 0) {
-    const flowName = path10.basename(rootPath, ".yaml");
-    await collectBaselineMembers(
+  return { members, flow, toolFiles, nestedRun, walk, sendBaselines };
+}
+async function collectFlowMembers(rootPath, rootBytes, args, opts) {
+  if (!namesValidFlow(args)) return {};
+  const canonical = await canonicalFlowPath(rootPath);
+  const spelling = await classifyOnDiskSpelling(
+    path10.dirname(rootPath),
+    path10.basename(rootPath),
+    FLOW_FILE_NAME_PATTERN
+  );
+  const collector = memberCollector(
+    await closureRoots(rootPath, canonical, args.project_root),
+    opts
+  );
+  await collector.walk([
+    {
       canonical,
-      flowName,
-      [...snapshots],
-      args,
-      roots,
-      budget,
-      opts,
-      emit
-    );
+      text: rootBytes.toString("utf8"),
+      flowName: path10.basename(rootPath, ".yaml"),
+      hop: 0,
+      updates: args.updateBaselines === true,
+      platform: callPlatform(args)
+    }
+  ]);
+  await collector.sendBaselines();
+  return { canonical, spelling, members: collector.members };
+}
+function recordedStep(args) {
+  const { command, args: text } = args;
+  if (typeof command !== "string") return void 0;
+  if (text === void 0) return { tool: command, args: {} };
+  if (typeof text !== "string") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  return { tool: command, args: parsed };
+}
+async function collectStepMembers(args, opts) {
+  const { name, project_root: projectRoot } = args;
+  const step = recordedStep(args);
+  if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name) || typeof projectRoot !== "string" || !path10.isAbsolute(projectRoot) || step === void 0) {
+    return [];
+  }
+  const recording = path10.join(projectRoot, ".argent", "flows", `${name}.yaml`);
+  const collector = memberCollector(
+    await closureRoots(recording, (await landing(recording)).canonical, projectRoot),
+    opts
+  );
+  await collector.toolFiles(step);
+  if (step.tool === "flow-execute") {
+    const self = await collector.flow(path10.dirname(recording), path10.basename(recording));
+    let runArgs = step.args;
+    const named = nestedFlowTarget(runArgs);
+    if (named?.kind === "flow_path") {
+      const stem = path10.basename(named.path, ".yaml");
+      if (path10.resolve(path10.dirname(named.path)) === path10.resolve(path10.dirname(recording))) {
+        await collector.flow(path10.dirname(recording), path10.basename(named.path));
+        runArgs = { ...runArgs, name: stem };
+        delete runArgs.flow_path;
+      }
+    }
+    const target = nestedFlowTarget(runArgs);
+    if (target?.kind === "name") {
+      await collector.flow(path10.dirname(self.member.canonical), `${target.name}.yaml`);
+      const run = await collector.nestedRun(
+        target,
+        0,
+        runArgs.updateBaselines === true,
+        callPlatform(runArgs)
+      );
+      if (run !== void 0) await collector.walk([run]);
+    }
   }
-  return { canonical, spelling, members };
+  await collector.sendBaselines();
+  return collector.members;
 }
 
 // ../argent-tools-client/src/tools-client.ts
@@ -9866,7 +10071,8 @@ function createToolsClient(options = {}) {
     opts?.signal?.throwIfAborted();
     const { url, token, remote } = await route();
     let finalArgs = args;
-    const meta = await fetchTool(name, { signal: opts?.signal });
+    const tools = await fetchTools({ signal: opts?.signal });
+    const meta = tools.find((t) => t.name === name) ?? null;
     const baselineDirs = [];
     if (meta?.fileInputs?.length) {
       if (remote) assertRequiredPresent(meta, args);
@@ -9876,6 +10082,8 @@ function createToolsClient(options = {}) {
         log: diagnose,
         baselineDirs,
         collectMembers: collectFlowMembers,
+        collectStepMembers,
+        toolFileInputs: (tool) => tools.find((t) => t.name === tool)?.fileInputs,
         signal: opts?.signal
       });
     }
@@ -9885,7 +10093,11 @@ function createToolsClient(options = {}) {
         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`);
+        for (const file of applied.written) {
+          if (baselineDirs.includes(path11.dirname(file))) {
+            diagnose(`[flow-files] baseline ${file}: written`);
+          }
+        }
       }
       return applied.result;
     };
@@ -9897,6 +10109,9 @@ function createToolsClient(options = {}) {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
+          // Tells the tool-server the call came over a link, a link to
+          // 127.0.0.1 included, which nothing else in the request shows.
+          ...remote ? { [LINKED_CALL_HEADER]: "1" } : {},
           // A proxy that compresses the stream holds each line until its buffer
           // fills. `identity` keeps the stream uncompressed end to end.
           ...stream ? { "Accept": "application/x-ndjson", "Accept-Encoding": "identity" } : {},
@@ -9957,7 +10172,7 @@ function createToolsClient(options = {}) {
 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 as normalize2, resolve as resolve6, sep as sep4 } from "node:path";
+import { basename as basename6, dirname as dirname8, extname as extname2, isAbsolute as isAbsolute6, join as join11, normalize as normalize2, resolve as resolve7, sep as sep4 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 var ARTIFACT_MARKER2 = "__argentArtifact";
 function isArtifactHandle(value) {
@@ -9990,7 +10205,7 @@ function artifactDir(deviceId) {
 }
 function durableBaseDir() {
   const projectRoot = findProjectRoot(process.cwd());
-  return projectRoot ?? dirname7(argentHomeDir());
+  return projectRoot ?? dirname8(argentHomeDir());
 }
 var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize2(".argent/recordings")]);
 var RECORDINGS_SAVE_DIR = normalize2(".argent/recordings");
@@ -10004,9 +10219,9 @@ function configuredRecordingsDir() {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   if (trimmed === "") return null;
-  const home = dirname7(argentHomeDir());
+  const home = dirname8(argentHomeDir());
   const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep4}`) ? join11(home, trimmed.slice(2)) : trimmed;
-  return resolve6(durableBaseDir(), expanded);
+  return resolve7(durableBaseDir(), expanded);
 }
 var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
 async function readCapped(res, cap) {
@@ -10039,10 +10254,10 @@ async function writeDurableUnique(dir, filename, write) {
   const stem = filename.slice(0, filename.length - ext.length);
   for (let i = 1; i <= 1e3; i++) {
     const candidate = i === 1 ? filename : `${stem} (${i})${ext}`;
-    const path12 = join11(dir, candidate);
+    const path13 = join11(dir, candidate);
     try {
-      await write(path12);
-      return path12;
+      await write(path13);
+      return path13;
     } catch (err) {
       if (err?.code === "EEXIST") continue;
       throw err;
@@ -10053,7 +10268,7 @@ async function writeDurableUnique(dir, filename, write) {
 function durableSaveTarget(handle) {
   if (typeof handle.saveDir !== "string" || !handle.saveDir || handle.archive) return null;
   const rel = normalize2(handle.saveDir);
-  if (isAbsolute5(rel) || rel === ".." || rel.startsWith(`..${sep4}`) || rel.split(sep4).includes("..")) {
+  if (isAbsolute6(rel) || rel === ".." || rel.startsWith(`..${sep4}`) || rel.split(sep4).includes("..")) {
     return null;
   }
   if (!ALLOWED_SAVE_DIRS.has(rel)) return null;
@@ -10226,11 +10441,11 @@ function getDeviceIdFromArgs(args) {
 
 // src/bundled-paths.ts
 import * as fs6 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 function readPackageVersion() {
   try {
     const pkg = JSON.parse(
-      fs6.readFileSync(path11.join(import.meta.dirname, "..", "package.json"), "utf8")
+      fs6.readFileSync(path12.join(import.meta.dirname, "..", "package.json"), "utf8")
     );
     return pkg.version;
   } catch {
@@ -10241,15 +10456,15 @@ var PACKAGE_NAME = "@swmansion/argent";
 function findDeclaringRoot(startDir) {
   let dir = startDir;
   for (; ; ) {
-    if (fs6.existsSync(path11.join(dir, ".argent", "install.json"))) return dir;
+    if (fs6.existsSync(path12.join(dir, ".argent", "install.json"))) return dir;
     try {
-      const manifest = JSON.parse(fs6.readFileSync(path11.join(dir, "package.json"), "utf8"));
+      const manifest = JSON.parse(fs6.readFileSync(path12.join(dir, "package.json"), "utf8"));
       if (manifest.devDependencies?.[PACKAGE_NAME] || manifest.dependencies?.[PACKAGE_NAME] || manifest.optionalDependencies?.[PACKAGE_NAME]) {
         return dir;
       }
     } catch {
     }
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -10257,12 +10472,12 @@ function findDeclaringRoot(startDir) {
 function findStablePackageDir(startDir, packageRoot) {
   let dir = startDir;
   for (; ; ) {
-    const candidate = path11.join(dir, "node_modules", PACKAGE_NAME);
+    const candidate = path12.join(dir, "node_modules", PACKAGE_NAME);
     try {
       if (fs6.realpathSync(candidate) === packageRoot) return candidate;
     } catch {
     }
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -10272,7 +10487,7 @@ function classifyInstall() {
   let dir;
   let cwd;
   try {
-    packageRoot = fs6.realpathSync(path11.join(import.meta.dirname, ".."));
+    packageRoot = fs6.realpathSync(path12.join(import.meta.dirname, ".."));
     cwd = process.cwd();
     dir = cwd;
   } catch {
@@ -10280,8 +10495,8 @@ function classifyInstall() {
   }
   for (; ; ) {
     try {
-      const nmReal = fs6.realpathSync(path11.join(dir, "node_modules"));
-      if (packageRoot === nmReal || packageRoot.startsWith(nmReal + path11.sep)) {
+      const nmReal = fs6.realpathSync(path12.join(dir, "node_modules"));
+      if (packageRoot === nmReal || packageRoot.startsWith(nmReal + path12.sep)) {
         return {
           kind: "local",
           projectRoot: findDeclaringRoot(cwd) ?? dir,
@@ -10290,22 +10505,22 @@ function classifyInstall() {
       }
     } catch {
     }
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  if (packageRoot.includes(`${path11.sep}.yarn${path11.sep}`)) {
+  if (packageRoot.includes(`${path12.sep}.yarn${path12.sep}`)) {
     const declRoot = findDeclaringRoot(cwd);
     if (declRoot) return { kind: "local", projectRoot: declRoot };
   }
   return { kind: "global" };
 }
 var classifiedInstall = classifyInstall();
-var packageDir = classifiedInstall.stablePackageDir ?? path11.join(import.meta.dirname, "..");
+var packageDir = classifiedInstall.stablePackageDir ?? path12.join(import.meta.dirname, "..");
 var BUNDLED_RUNTIME_PATHS = {
-  bundlePath: path11.join(packageDir, "dist", "tool-server.cjs"),
-  simulatorServerDir: path11.join(packageDir, "bin"),
-  nativeDevtoolsDir: path11.join(packageDir, "dylibs"),
+  bundlePath: path12.join(packageDir, "dist", "tool-server.cjs"),
+  simulatorServerDir: path12.join(packageDir, "bin"),
+  nativeDevtoolsDir: path12.join(packageDir, "dylibs"),
   version: readPackageVersion(),
   installKind: classifiedInstall.kind,
   installProjectRoot: classifiedInstall.projectRoot