@swmansion/argent 0.10.0 → 0.11.0

package/dist/mcp-server.mjs

@@ -2980,7 +2980,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.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 +3007,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 resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3225,8 +3225,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path4) {
+      let input = path4;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3478,8 +3478,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 [path4, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3638,7 +3638,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(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 +3896,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -6872,12 +6872,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs2, exportName) {
+    function addFormats(ajv, list, fs3, 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, fs3[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6886,9 +6886,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 mkdir4 } from "node:fs/promises";
+import { dirname as dirname2 } 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 +7133,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7545,11 +7545,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -7696,16 +7696,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, path4 = []) => {
     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 }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -13697,12 +13697,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -14300,7 +14300,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -14317,7 +14317,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -14395,7 +14395,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -14611,21 +14611,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 +14656,19 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, 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 +14681,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 +14705,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 +14729,7 @@ var Protocol = class {
         }
       },
       listTasks: (cursor) => {
-        return taskStore.listTasks(cursor, sessionId);
+        return taskStore.listTasks(cursor, sessionId2);
       }
     };
   }
@@ -15080,8 +15080,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 +15424,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 +15483,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -15494,7 +15494,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve(port);
+        else resolve2(port);
       });
     });
     srv.on("error", reject);
@@ -15536,7 +15536,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((resolve2, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -15568,7 +15568,7 @@ function spawnToolsServer(paths, port, options = {}) {
         const actualPort = parseInt(match[1], 10);
         rl.close();
         child.stdout?.resume();
-        settle(() => resolve({ port: actualPort, pid }));
+        settle(() => resolve2({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -15699,9 +15699,144 @@ async function isRemoteRouted() {
   return url !== null;
 }
 
+// ../argent-tools-client/src/artifacts.ts
+import { mkdir as mkdir3, readFile as readFile3, rm, stat, writeFile as writeFile3 } 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 stat(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 writeFile3(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 mkdir3(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 readFile3(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 writeFile3(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 readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } 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 +15849,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 [
       {
@@ -15750,7 +15901,7 @@ function isScreenshotDiffResult(value) {
 async function screenshotDiffToMcpContent(result) {
   const blocks = [];
   if (typeof result.contextDiffPath === "string") {
-    const buf = await readFile3(result.contextDiffPath);
+    const buf = await readFile4(result.contextDiffPath);
     blocks.push({
       type: "image",
       data: buf.toString("base64"),
@@ -15760,7 +15911,7 @@ async function screenshotDiffToMcpContent(result) {
   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 +15935,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,6 +15943,64 @@ async function flowRunToMcpContent(result) {
   return blocks;
 }
 
+// ../configuration-core/src/flags.ts
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import { homedir as homedir3 } from "node:os";
+var PROJECT_MARKERS = [".argent", ".git", "package.json"];
+function resolveProjectRoot(startDir) {
+  const initial = path3.resolve(startDir);
+  let current = initial;
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs2.existsSync(path3.join(current, marker))) return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) return initial;
+    current = parent;
+  }
+}
+function getFlagsPath(scope, options = {}) {
+  const home = options.homeDir ?? homedir3();
+  if (scope === "global") {
+    return path3.join(home, ".argent", "flags.json");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path3.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",
@@ -15824,9 +16033,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") {
@@ -15897,6 +16105,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 +16139,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 mkdir4(dirname2(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");
@@ -16006,21 +16215,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);
       } 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 +16301,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(() => {
       });