@swmansion/argent 0.10.0 → 0.12.0

package/dist/mcp-server.mjs

@@ -6,7 +6,11 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -2980,7 +2984,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve3.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3007,7 +3011,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve3(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3225,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path6) {
+      let input = path6;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3478,8 +3482,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path6, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path6 && path6 !== "/" ? path6 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3638,7 +3642,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve3(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3896,7 +3900,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve3,
       resolveComponent,
       equal,
       serialize,
@@ -6872,12 +6876,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs2, exportName) {
+    function addFormats(ajv, list, fs4, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs2[f]);
+        ajv.addFormat(f, fs4[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6886,9 +6890,9 @@ var require_dist = __commonJS({
 });
 
 // ../argent-mcp/src/mcp-server.ts
-import { appendFile, mkdir as mkdir3 } from "node:fs/promises";
-import { dirname } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { appendFile, mkdir as mkdir5 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process3 from "node:process";
@@ -7133,10 +7137,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7545,11 +7549,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -7696,16 +7700,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path3 = []) => {
+  const processError = (error3, path6 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -13697,12 +13701,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve3();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve3);
       }
     });
   }
@@ -14300,7 +14304,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -14317,7 +14321,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -14395,7 +14399,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve3(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -14611,21 +14615,21 @@ var Protocol = class {
    * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
    * simply propagates the error.
    */
-  async _enqueueTaskMessage(taskId, message, sessionId) {
+  async _enqueueTaskMessage(taskId, message, sessionId2) {
     if (!this._taskStore || !this._taskMessageQueue) {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId2, maxQueueSize);
   }
   /**
    * Clears the message queue for a task and rejects any pending request resolvers.
    * @param taskId The task ID whose queue should be cleared
    * @param sessionId Optional session ID for binding the operation to a specific session
    */
-  async _clearTaskQueue(taskId, sessionId) {
+  async _clearTaskQueue(taskId, sessionId2) {
     if (this._taskMessageQueue) {
-      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId2);
       for (const message of messages) {
         if (message.type === "request" && isJSONRPCRequest(message.message)) {
           const requestId = message.message.id;
@@ -14656,19 +14660,19 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve3, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
       }, { once: true });
     });
   }
-  requestTaskStore(request, sessionId) {
+  requestTaskStore(request, sessionId2) {
     const taskStore = this._taskStore;
     if (!taskStore) {
       throw new Error("No task store configured");
@@ -14681,18 +14685,18 @@ var Protocol = class {
         return await taskStore.createTask(taskParams, request.id, {
           method: request.method,
           params: request.params
-        }, sessionId);
+        }, sessionId2);
       },
       getTask: async (taskId) => {
-        const task = await taskStore.getTask(taskId, sessionId);
+        const task = await taskStore.getTask(taskId, sessionId2);
         if (!task) {
           throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
         }
         return task;
       },
       storeTaskResult: async (taskId, status, result) => {
-        await taskStore.storeTaskResult(taskId, status, result, sessionId);
-        const task = await taskStore.getTask(taskId, sessionId);
+        await taskStore.storeTaskResult(taskId, status, result, sessionId2);
+        const task = await taskStore.getTask(taskId, sessionId2);
         if (task) {
           const notification = TaskStatusNotificationSchema.parse({
             method: "notifications/tasks/status",
@@ -14705,18 +14709,18 @@ var Protocol = class {
         }
       },
       getTaskResult: (taskId) => {
-        return taskStore.getTaskResult(taskId, sessionId);
+        return taskStore.getTaskResult(taskId, sessionId2);
       },
       updateTaskStatus: async (taskId, status, statusMessage) => {
-        const task = await taskStore.getTask(taskId, sessionId);
+        const task = await taskStore.getTask(taskId, sessionId2);
         if (!task) {
           throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
         }
         if (isTerminal(task.status)) {
           throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
         }
-        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
-        const updatedTask = await taskStore.getTask(taskId, sessionId);
+        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId2);
+        const updatedTask = await taskStore.getTask(taskId, sessionId2);
         if (updatedTask) {
           const notification = TaskStatusNotificationSchema.parse({
             method: "notifications/tasks/status",
@@ -14729,7 +14733,7 @@ var Protocol = class {
         }
       },
       listTasks: (cursor) => {
-        return taskStore.listTasks(cursor, sessionId);
+        return taskStore.listTasks(cursor, sessionId2);
       }
     };
   }
@@ -15080,8 +15084,8 @@ var Server = class extends Protocol {
     this._serverInfo = _serverInfo;
     this._loggingLevels = /* @__PURE__ */ new Map();
     this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
-    this.isMessageIgnored = (level, sessionId) => {
-      const currentLevel = this._loggingLevels.get(sessionId);
+    this.isMessageIgnored = (level, sessionId2) => {
+      const currentLevel = this._loggingLevels.get(sessionId2);
       return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
     };
     this._capabilities = options?.capabilities ?? {};
@@ -15424,9 +15428,9 @@ var Server = class extends Protocol {
    * @param params
    * @param sessionId optional for stateless and backward compatibility
    */
-  async sendLoggingMessage(params, sessionId) {
+  async sendLoggingMessage(params, sessionId2) {
     if (this._capabilities.logging) {
-      if (!this.isMessageIgnored(params.level, sessionId)) {
+      if (!this.isMessageIgnored(params.level, sessionId2)) {
         return this.notification({ method: "notifications/message", params });
       }
     }
@@ -15483,7 +15487,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -15494,7 +15498,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve(port);
+        else resolve3(port);
       });
     });
     srv.on("error", reject);
@@ -15536,7 +15540,7 @@ async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, t
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -15568,7 +15572,7 @@ function spawnToolsServer(paths, port, options = {}) {
         const actualPort = parseInt(match[1], 10);
         rl.close();
         child.stdout?.resume();
-        settle(() => resolve({ port: actualPort, pid }));
+        settle(() => resolve3({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -15699,9 +15703,236 @@ async function isRemoteRouted() {
   return url !== null;
 }
 
-// ../argent-mcp/src/content.ts
+// ../argent-tools-client/src/file-inputs.ts
+import { mkdir as mkdir3, stat, writeFile as writeFile3 } from "node:fs/promises";
 import { readFile as readFile3 } from "node:fs/promises";
+import * as path3 from "node:path";
+var FILE_INPUT_MARKER = "__argentFileInput";
+var CLIENT_FILE_MARKER = "__argentClientFile";
+var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
+function interpolatePath(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;
+}
+async function prepareFileInputs(specs, args, opts) {
+  if (!specs || specs.length === 0 || typeof args !== "object" || args === null) {
+    return args;
+  }
+  const record2 = args;
+  let out = null;
+  for (const spec of specs) {
+    if (spec.target in record2 && typeof record2[spec.target] !== "string") continue;
+    const filePath = interpolatePath(spec.path, record2);
+    if (filePath === null) continue;
+    if (spec.target in record2 && record2[spec.target] !== filePath) continue;
+    const wire = { [FILE_INPUT_MARKER]: true, path: filePath };
+    if (spec.kind === "file") {
+      try {
+        const st = await stat(filePath);
+        if (st.isFile()) {
+          wire.size = st.size;
+          wire.mtimeMs = st.mtimeMs;
+          if (opts.includeContent && st.size <= MAX_CONTENT_BYTES) {
+            wire.content = (await readFile3(filePath)).toString("base64");
+          } else if (opts.includeContent) {
+            wire.contentOmitted = "size-limit";
+          }
+        }
+      } catch {
+      }
+    }
+    out = out ?? { ...record2 };
+    out[spec.target] = wire;
+  }
+  return out ?? args;
+}
+function isAllowedClientFilePath(p) {
+  if (!path3.isAbsolute(p)) return false;
+  const segments = p.split(/[\\/]+/);
+  if (segments.includes("..")) return false;
+  const file = segments[segments.length - 1] ?? "";
+  if (!/^[A-Za-z0-9_-]+\.yaml$/.test(file)) return false;
+  return segments[segments.length - 3] === ".argent" && segments[segments.length - 2] === "flows";
+}
+function isClientFileDirective(value) {
+  return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER] === true && typeof value.path === "string" && typeof value.content === "string";
+}
+async function applyClientFileDirectives(result) {
+  const written = [];
+  async function walk(value) {
+    if (isClientFileDirective(value)) {
+      if (!isAllowedClientFilePath(value.path)) return null;
+      try {
+        await mkdir3(path3.dirname(value.path), { recursive: true });
+        await writeFile3(value.path, value.content, "utf8");
+        written.push(value.path);
+        return value.path;
+      } catch {
+        return null;
+      }
+    }
+    if (Array.isArray(value)) {
+      return Promise.all(value.map(walk));
+    }
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = await walk(v);
+      }
+      return out;
+    }
+    return value;
+  }
+  const rewritten = await walk(result);
+  return { result: rewritten, written };
+}
+
+// ../argent-tools-client/src/artifacts.ts
+import { mkdir as mkdir4, readFile as readFile4, rm, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join as join3 } from "node:path";
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var ARTIFACT_MARKER = "__argentArtifact";
+function isArtifactHandle(value) {
+  return !!value && typeof value === "object" && value[ARTIFACT_MARKER] === true && typeof value.id === "string" && typeof value.filename === "string";
+}
+var SESSION_ID = null;
+function sessionId() {
+  if (!SESSION_ID) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, (m) => m === "T" ? "-" : "").slice(0, 15);
+    SESSION_ID = `${stamp}-${process.pid}`;
+  }
+  return SESSION_ID;
+}
+function sanitizeSegment(segment) {
+  return segment.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function projectSlug() {
+  const cwd = process.cwd();
+  const hash = createHash("sha1").update(cwd).digest("hex").slice(0, 6);
+  const name = sanitizeSegment(basename(cwd)) || "root";
+  return `${name}-${hash}`;
+}
+function artifactsRoot() {
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join3(tmpdir(), "argent-artifacts");
+}
+function artifactDir(deviceId) {
+  const parts = [artifactsRoot(), projectSlug(), sessionId()];
+  if (deviceId) parts.push(sanitizeSegment(deviceId));
+  return join3(...parts);
+}
+async function resolveLocalFile(handle) {
+  if (!handle.hostPath) return null;
+  try {
+    const st = await stat2(handle.hostPath);
+    if (handle.archive) {
+      return st.isDirectory() ? handle.hostPath : null;
+    }
+    if (!st.isFile()) return null;
+    if (st.size !== handle.size) return null;
+    if (handle.mtimeMs != null && Math.round(st.mtimeMs) !== Math.round(handle.mtimeMs)) {
+      return null;
+    }
+    return handle.hostPath;
+  } catch {
+    return null;
+  }
+}
+async function downloadAndExtractArchive(handle, data, dir) {
+  const tarball = join3(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  try {
+    await writeFile4(tarball, data);
+    await execFileAsync("tar", ["-xzf", tarball, "-C", dir]);
+    return join3(dir, handle.filename);
+  } catch {
+    return null;
+  } finally {
+    await rm(tarball, { force: true }).catch(() => {
+    });
+  }
+}
+async function materializeArtifacts(result, ctx) {
+  const images = [];
+  const fetchFn = ctx.fetchImpl ?? fetch;
+  const authHeaders2 = ctx.authToken ? { Authorization: `Bearer ${ctx.authToken}` } : {};
+  const dir = artifactDir(ctx.deviceId);
+  let dirReady = false;
+  async function ensureDir() {
+    if (!dirReady) {
+      await mkdir4(dir, { recursive: true });
+      dirReady = true;
+    }
+  }
+  async function walk(value) {
+    if (isArtifactHandle(value)) {
+      const localPath = await resolveLocalFile(value);
+      if (localPath) {
+        if (value.mimeType.startsWith("image/")) {
+          images.push({ localPath, data: await readFile4(localPath), mimeType: value.mimeType });
+        }
+        return localPath;
+      }
+      try {
+        const res = await fetchFn(`${ctx.toolsUrl}/artifacts/${value.id}`, {
+          headers: authHeaders2
+        });
+        if (!res.ok) return null;
+        const data = Buffer.from(await res.arrayBuffer());
+        await ensureDir();
+        if (value.archive === "tar.gz") {
+          return await downloadAndExtractArchive(value, data, dir);
+        }
+        if (value.size > 0 && data.length !== value.size) return null;
+        const downloadedPath = join3(dir, sanitizeSegment(value.filename));
+        await writeFile4(downloadedPath, data);
+        if (value.mimeType.startsWith("image/")) {
+          images.push({ localPath: downloadedPath, data, mimeType: value.mimeType });
+        }
+        return downloadedPath;
+      } catch {
+        return null;
+      }
+    }
+    if (Array.isArray(value)) {
+      return Promise.all(value.map(walk));
+    }
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = await walk(v);
+      }
+      return out;
+    }
+    return value;
+  }
+  const rewritten = await walk(result);
+  return { result: rewritten, images };
+}
+function getDeviceIdFromArgs(args) {
+  if (!args || typeof args !== "object") return void 0;
+  const rec = args;
+  if (typeof rec.udid === "string") return rec.udid;
+  if (typeof rec.device_id === "string") return rec.device_id;
+  return void 0;
+}
+
+// ../argent-mcp/src/content.ts
+import { readFile as readFile5 } from "node:fs/promises";
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function imageBlock(data, mimeType) {
+  return { type: "image", data: data.toString("base64"), mimeType };
+}
 async function fetchPngBytes(url) {
   try {
     const res = await fetch(url);
@@ -15714,22 +15945,38 @@ async function fetchPngBytes(url) {
     return null;
   }
 }
-async function toMcpContent(result, outputHint, args) {
-  if (outputHint === "image" && result && typeof result === "object" && "url" in result) {
+async function toMcpContent(result, outputHint, ctx, args) {
+  const suppressImage = isRecord(args) && args.includeImageInContext === false;
+  if (ctx) {
+    const { result: rewritten, images } = await materializeArtifacts(result, ctx);
+    if (outputHint === "image") {
+      if (images.length > 0) {
+        const saved = { type: "text", text: `Saved: ${images[0].localPath}` };
+        if (suppressImage) return [saved];
+        const blocks2 = images.map((img) => imageBlock(img.data, img.mimeType));
+        blocks2.push(saved);
+        return blocks2;
+      }
+      return legacyImageContent(rewritten, suppressImage);
+    }
+    const blocks = [{ type: "text", text: JSON.stringify(rewritten, null, 2) }];
+    if (!suppressImage) for (const img of images) blocks.push(imageBlock(img.data, img.mimeType));
+    return blocks;
+  }
+  if (outputHint === "image") {
+    return legacyImageContent(result, suppressImage);
+  }
+  return [{ type: "text", text: JSON.stringify(result, null, 2) }];
+}
+async function legacyImageContent(result, suppressImage) {
+  if (result && typeof result === "object" && "url" in result) {
     const r = result;
-    if (isRecord(args) && args.includeImageInContext === false) {
-      return [{ type: "text", text: `Saved: ${r.path}` }];
+    if (suppressImage) {
+      return [{ type: "text", text: `Saved: ${r.path ?? ""}` }];
     }
     const buf = await fetchPngBytes(r.url);
     if (buf) {
-      return [
-        {
-          type: "image",
-          data: buf.toString("base64"),
-          mimeType: "image/png"
-        },
-        { type: "text", text: `Saved: ${r.path ?? ""}` }
-      ];
+      return [imageBlock(buf, "image/png"), { type: "text", text: `Saved: ${r.path ?? ""}` }];
     }
     return [
       {
@@ -15747,20 +15994,39 @@ function isScreenshotDiffResult(value) {
   if (!isRecord(value)) return false;
   return typeof value.summary === "string";
 }
-async function screenshotDiffToMcpContent(result) {
+async function screenshotDiffToMcpContent(result, ctx) {
   const blocks = [];
-  if (typeof result.contextDiffPath === "string") {
-    const buf = await readFile3(result.contextDiffPath);
-    blocks.push({
-      type: "image",
-      data: buf.toString("base64"),
-      mimeType: "image/png"
-    });
+  let contextDiffPath = result.contextDiffPath;
+  let materializedImages = [];
+  if (ctx) {
+    const { result: rewritten, images } = await materializeArtifacts(result, ctx);
+    contextDiffPath = rewritten.contextDiffPath;
+    materializedImages = images;
+  }
+  if (typeof contextDiffPath === "string") {
+    const fromMaterializer = materializedImages.find((img) => img.localPath === contextDiffPath);
+    if (fromMaterializer) {
+      blocks.push({
+        type: "image",
+        data: fromMaterializer.data.toString("base64"),
+        mimeType: fromMaterializer.mimeType
+      });
+    } else {
+      try {
+        const buf = await readFile5(contextDiffPath);
+        blocks.push({
+          type: "image",
+          data: buf.toString("base64"),
+          mimeType: "image/png"
+        });
+      } catch {
+      }
+    }
   }
   blocks.push({ type: "text", text: result.summary });
   return blocks;
 }
-async function flowRunToMcpContent(result) {
+async function flowRunToMcpContent(result, ctx) {
   const blocks = [];
   if (result.executionPrerequisite) {
     blocks.push({
@@ -15784,7 +16050,7 @@ async function flowRunToMcpContent(result) {
       });
     } else {
       blocks.push({ type: "text", text: `[${num}] ${step.tool}` });
-      const stepContent = await toMcpContent(step.result, step.outputHint, step.args);
+      const stepContent = await toMcpContent(step.result, step.outputHint, ctx, step.args);
       blocks.push(...stepContent);
     }
   }
@@ -15792,10 +16058,70 @@ async function flowRunToMcpContent(result) {
   return blocks;
 }
 
+// ../configuration-core/src/flags.ts
+import * as fs2 from "node:fs";
+import * as path4 from "node:path";
+import { homedir as homedir3 } from "node:os";
+var PROJECT_MARKERS = [".argent", ".git", "package.json"];
+function resolveProjectRoot(startDir) {
+  const initial = path4.resolve(startDir);
+  let current = initial;
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs2.existsSync(path4.join(current, marker))) return current;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) return initial;
+    current = parent;
+  }
+}
+function getFlagsPath(scope, options = {}) {
+  const home = options.homeDir ?? homedir3();
+  if (scope === "global") {
+    return path4.join(home, ".argent", "flags.json");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path4.join(resolveProjectRoot(cwd), ".argent", "flags.json");
+}
+function readFlagsFile(filePath) {
+  let raw;
+  try {
+    raw = fs2.readFileSync(filePath, "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const flags = parsed.flags;
+  if (!flags || typeof flags !== "object" || Array.isArray(flags)) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(flags)) {
+    if (typeof v === "boolean") out[k] = v;
+  }
+  return out;
+}
+function readFlags(scope, options = {}) {
+  return readFlagsFile(getFlagsPath(scope, options));
+}
+function isFlagEnabled(name, options = {}) {
+  const projectFlags = readFlags("project", options);
+  if (Object.hasOwn(projectFlags, name)) return projectFlags[name];
+  const globalFlags = readFlags("global", options);
+  if (Object.hasOwn(globalFlags, name)) return globalFlags[name];
+  return false;
+}
+
 // ../argent-mcp/src/auto-screenshot.ts
 var AUTO_SCREENSHOT_TOOLS = /* @__PURE__ */ new Set([
   "gesture-tap",
   "gesture-swipe",
+  "gesture-scroll",
+  "gesture-drag",
   "gesture-custom",
   "gesture-pinch",
   "gesture-rotate",
@@ -15813,6 +16139,8 @@ var AUTO_SCREENSHOT_DELAY_MS_BY_TOOL = {
   "restart-app": 3e3,
   "open-url": 2e3,
   "gesture-swipe": 1500,
+  "gesture-scroll": 1500,
+  "gesture-drag": 1500,
   "gesture-custom": 1500,
   "gesture-tap": 1500,
   "gesture-pinch": 1500,
@@ -15824,9 +16152,8 @@ var AUTO_SCREENSHOT_DELAY_MS_BY_TOOL = {
   "describe": 100
 };
 var DEFAULT_DELAY_MS = 1400;
-function autoScreenshotEnabled() {
-  const v = process.env.ARGENT_AUTO_SCREENSHOT;
-  return v === void 0 || v === "" || v === "1" || v.toLowerCase() === "true";
+function autoScreenshotEnabled(options) {
+  return !isFlagEnabled("disable-auto-screenshot", options);
 }
 function getUdidFromArgs(args) {
   if (args && typeof args === "object" && "udid" in args && typeof args.udid === "string") {
@@ -15866,6 +16193,19 @@ function toMcpTool(t) {
   };
 }
 
+// ../argent-mcp/src/installed-version.ts
+import * as fs3 from "node:fs";
+import * as path5 from "node:path";
+function getInstalledVersion() {
+  try {
+    const pkgPath = path5.resolve(import.meta.dirname, "..", "package.json");
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
 // ../argent-mcp/src/mcp-server.ts
 var MAX_RETRIES = 4;
 var EXP_BACKOFF_BASE = 250;
@@ -15897,6 +16237,7 @@ async function fetchWithReconnect(getUrl, reconnect, config2) {
   throw lastError;
 }
 async function startMcpServer(options) {
+  const autoScreenshotOn = autoScreenshotEnabled();
   let TOOLS_URL;
   let AUTH_TOKEN;
   const resolved = await getResolvedToolsUrl();
@@ -15930,12 +16271,12 @@ async function startMcpServer(options) {
     }
     return reconnectPromise;
   }
-  const LOG_FILE2 = process.env.ARGENT_MCP_LOG ?? `${homedir3()}/.argent/mcp-calls.log`;
+  const LOG_FILE2 = process.env.ARGENT_MCP_LOG ?? `${homedir4()}/.argent/mcp-calls.log`;
   let logDirReady = false;
   async function spyLog(entry) {
     try {
       if (!logDirReady) {
-        await mkdir3(dirname(LOG_FILE2), { recursive: true });
+        await mkdir5(dirname3(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");
@@ -15952,23 +16293,33 @@ async function startMcpServer(options) {
   async function callTool(name, args) {
     const tools = await fetchTools();
     const meta2 = tools.find((t) => t.name === name);
+    let finalArgs = args;
+    if (meta2?.fileInputs?.length) {
+      finalArgs = await prepareFileInputs(meta2.fileInputs, args ?? {}, {
+        // `resolved` is the startup routing decision that picked TOOLS_URL —
+        // an external target means this process may not share the server's
+        // filesystem, so file bytes must ride along.
+        includeContent: resolved.url !== null
+      });
+    }
     const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools/${name}`, reconnect, {
       init: {
         method: "POST",
         headers: { "Content-Type": "application/json", ...authHeader() },
-        body: JSON.stringify(args ?? {})
+        body: JSON.stringify(finalArgs ?? {})
       },
       fetchTimeoutMs: meta2?.longRunning ? null : FETCH_TIMEOUT_MS
     });
     const json = await res.json();
     if (!res.ok) throw new Error(json.error ?? json.message ?? res.statusText);
-    return { result: json.data, outputHint: meta2?.outputHint, note: json.note };
+    const { result: data } = await applyClientFileDirectives(json.data);
+    return { result: data, outputHint: meta2?.outputHint, note: json.note };
   }
   const server = new Server(
-    { name: "argent", version: "0.5.3" },
+    { name: "argent", version: getInstalledVersion() },
     {
       capabilities: { tools: {} },
-      instructions: "Argent \u2014 iOS Simulator and Android Emulator control for interacting, testing, profiling and debugging mobile applications. Always use discovery tools (describe / debugger-component-tree / screenshot) before tapping \u2014 never guess coordinates. On session end: call stop-all-simulator-servers and perform any necessary cleanup. Full guidance is in the argent rule loaded from .claude/rules/argent.md."
+      instructions: "Argent \u2014 iOS Simulator, Android Emulator, and Chromium app control for interacting, testing, profiling and debugging mobile and Chromium applications. Always use discovery tools (describe / debugger-component-tree / screenshot) before tapping \u2014 never guess coordinates. On session end: call stop-all-simulator-servers and perform any necessary cleanup. Full guidance is in the argent rule loaded from .claude/rules/argent.md."
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -16006,21 +16357,30 @@ async function startMcpServer(options) {
         isError: false,
         result
       });
+      const ctx = {
+        toolsUrl: TOOLS_URL,
+        authToken: AUTH_TOKEN,
+        deviceId: getDeviceIdFromArgs(params.arguments)
+      };
       let content;
       if (params.name === "flow-execute" && result && typeof result === "object" && "flow" in result && "steps" in result) {
-        content = await flowRunToMcpContent(result);
+        content = await flowRunToMcpContent(result, ctx);
       } else if (params.name === "screenshot-diff" && isScreenshotDiffResult(result)) {
-        content = await screenshotDiffToMcpContent(result);
+        content = await screenshotDiffToMcpContent(result, ctx);
       } else {
-        content = await toMcpContent(result, outputHint, params.arguments);
+        content = await toMcpContent(result, outputHint, ctx, params.arguments);
       }
       const udid = getUdidFromArgs(params.arguments);
-      if (autoScreenshotEnabled() && udid && shouldAutoScreenshot(params.name)) {
+      if (autoScreenshotOn && udid && shouldAutoScreenshot(params.name)) {
         const delayMs = getAutoScreenshotDelayMs(params.name);
         if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
         try {
           const screenshotResult = await callTool("screenshot", { udid });
-          const screenshotContent = await toMcpContent(screenshotResult.result, "image", { udid });
+          const screenshotContent = await toMcpContent(screenshotResult.result, "image", {
+            toolsUrl: TOOLS_URL,
+            authToken: AUTH_TOKEN,
+            deviceId: udid
+          });
           const hasImage = screenshotContent.some((b) => b.type === "image");
           if (hasImage) {
             content = [
@@ -16083,7 +16443,7 @@ async function startMcpServer(options) {
     }, HEALTH_INTERVAL_MS);
     healthInterval.unref();
   }
-  if (process.env.ARGENT_AUTO_SHUTDOWN === "1") {
+  if (process.env.ARGENT_TOOL_SERVER_SHUTDOWN_ON_MCP_EXIT === "1") {
     process.stdin.on("close", () => {
       fetch(`${TOOLS_URL}/shutdown`, { method: "POST", headers: authHeader() }).catch(() => {
       });