@swmansion/argent 0.9.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(path2) {
-      let input = path2;
+    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 [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : 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 mkdir2 } from "node:fs/promises";
-import { dirname } from "node:path";
-import { homedir as homedir2 } 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, path2) {
-  if (!path2)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path2.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(path2, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path2);
+    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, path2 = []) => {
+  const processError = (error3, path4 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...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 });
       }
     }
@@ -15457,20 +15457,33 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { mkdir, writeFile, readFile, unlink } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
-function buildToolsServerEnv(paths, port, baseEnv = process.env) {
-  return {
+var AUTH_TOKEN_BYTES = 32;
+var AUTH_TOKEN_ENV = "ARGENT_AUTH_TOKEN";
+var AUTOSPAWN_IDLE_TIMEOUT_MINUTES = 30;
+function buildToolsServerEnv(paths, port, baseEnv = process.env, options = {}) {
+  const env = {
     ...baseEnv,
-    PORT: String(port),
+    ARGENT_PORT: String(port),
     ARGENT_SIMULATOR_SERVER_DIR: paths.simulatorServerDir,
     ARGENT_NATIVE_DEVTOOLS_DIR: paths.nativeDevtoolsDir
   };
+  if (options.host !== void 0) env.ARGENT_HOST = options.host;
+  if (options.idleTimeoutMinutes !== void 0) {
+    env.ARGENT_IDLE_TIMEOUT_MINUTES = String(options.idleTimeoutMinutes);
+  }
+  if (options.token) env[AUTH_TOKEN_ENV] = options.token;
+  return env;
+}
+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();
@@ -15481,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);
@@ -15495,12 +15508,25 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-async function isHealthy(port) {
+function healthCheckHost(host) {
+  if (host === "0.0.0.0" || host === "") return "127.0.0.1";
+  if (host === "::" || host === "::0") return "::1";
+  return host;
+}
+function formatUrl(host, port) {
+  const h = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${h}:${port}`;
+}
+function authHeaders(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, token) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 2e3);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/tools`, {
-      signal: controller.signal
+    const res = await fetch(`${formatUrl(healthCheckHost(host), port)}/tools`, {
+      signal: controller.signal,
+      headers: authHeaders(token)
     });
     return res.ok;
   } catch {
@@ -15509,8 +15535,8 @@ async function isHealthy(port) {
     clearTimeout(timer);
   }
 }
-function spawnToolsServer(paths, port) {
-  return new Promise((resolve, reject) => {
+function spawnToolsServer(paths, port, options = {}) {
+  return new Promise((resolve2, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -15521,7 +15547,7 @@ function spawnToolsServer(paths, port) {
     const child = spawn("node", [paths.bundlePath, "start"], {
       detached: true,
       stdio: ["ignore", "pipe", logFd],
-      env: buildToolsServerEnv(paths, port)
+      env: buildToolsServerEnv(paths, port, process.env, options)
     });
     child.unref();
     const pid = child.pid;
@@ -15537,12 +15563,12 @@ function spawnToolsServer(paths, port) {
     };
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
-      const match = line.match(/Tools server listening on http:\/\/127\.0\.0\.1:(\d+)/);
+      const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
       if (match) {
         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) => {
@@ -15560,7 +15586,7 @@ function spawnToolsServer(paths, port) {
     rl.on("close", () => clearTimeout(timer));
   });
 }
-async function readState() {
+async function readToolsServerState() {
   try {
     const raw = await readFile(STATE_FILE, "utf8");
     return JSON.parse(raw);
@@ -15568,42 +15594,249 @@ async function readState() {
     return null;
   }
 }
-async function writeState(state) {
+async function writeToolsServerState(state) {
   await mkdir(STATE_DIR, { recursive: true });
-  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + "\n", "utf8");
+  const tmp = `${STATE_FILE}.${process.pid}.tmp`;
+  try {
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(tmp, 384);
+    await rename(tmp, STATE_FILE);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
 }
-async function clearState() {
+async function clearToolsServerState() {
   try {
     await unlink(STATE_FILE);
   } catch {
   }
 }
+var readState = readToolsServerState;
+var writeState = writeToolsServerState;
+var clearState = clearToolsServerState;
 async function ensureToolsServer(paths) {
   const state = await readState();
   if (state) {
     const alive = isProcessAlive(state.pid);
     if (alive) {
-      const healthy = await isHealthy(state.port);
+      const host = state.host ?? "127.0.0.1";
+      const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
       if (healthy) {
-        return `http://127.0.0.1:${state.port}`;
+        return {
+          url: formatUrl(healthCheckHost(host), state.port),
+          token: state.token ?? ""
+        };
       }
     }
     await clearState();
   }
+  const token = generateToken();
   const port = await findFreePort();
-  const { port: actualPort, pid } = await spawnToolsServer(paths, port);
+  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+    token,
+    idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
+  });
   await writeState({
     port: actualPort,
     pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundlePath: paths.bundlePath
+    bundlePath: paths.bundlePath,
+    host: "127.0.0.1",
+    token
   });
-  return `http://127.0.0.1:${actualPort}`;
+  return { url: formatUrl("127.0.0.1", actualPort), token };
+}
+
+// ../argent-tools-client/src/link-config.ts
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2, unlink as unlink2, chmod as chmod2 } from "node:fs/promises";
+var LINK_DIR = path2.join(homedir2(), ".argent");
+var LINK_FILE = path2.join(LINK_DIR, "link.json");
+async function readLinkConfig() {
+  try {
+    const raw = await readFile2(LINK_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.url !== "string" || typeof parsed.host !== "string" || typeof parsed.port !== "number" || typeof parsed.createdAt !== "string") {
+      return null;
+    }
+    return {
+      url: parsed.url,
+      host: parsed.host,
+      port: parsed.port,
+      createdAt: parsed.createdAt,
+      ...typeof parsed.token === "string" ? { token: parsed.token } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function getResolvedToolsUrl() {
+  const envUrl = process.env.ARGENT_TOOLS_URL;
+  if (envUrl) {
+    const link2 = await readLinkConfig();
+    const envToken = process.env[AUTH_TOKEN_ENV];
+    return {
+      url: envUrl,
+      source: "env",
+      ...envToken ? { token: envToken } : {},
+      ...link2 ? { shadowedLink: link2 } : {}
+    };
+  }
+  const link = await readLinkConfig();
+  if (link) {
+    return { url: link.url, source: "link", ...link.token ? { token: link.token } : {} };
+  }
+  return { url: null, source: "none" };
+}
+async function isRemoteRouted() {
+  const { url } = await getResolvedToolsUrl();
+  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 readFile2 } 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);
@@ -15616,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 [
       {
@@ -15652,7 +15901,7 @@ function isScreenshotDiffResult(value) {
 async function screenshotDiffToMcpContent(result) {
   const blocks = [];
   if (typeof result.contextDiffPath === "string") {
-    const buf = await readFile2(result.contextDiffPath);
+    const buf = await readFile4(result.contextDiffPath);
     blocks.push({
       type: "image",
       data: buf.toString("base64"),
@@ -15662,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({
@@ -15686,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);
     }
   }
@@ -15694,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",
@@ -15726,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") {
@@ -15799,36 +16105,46 @@ async function fetchWithReconnect(getUrl, reconnect, config2) {
   throw lastError;
 }
 async function startMcpServer(options) {
+  const autoScreenshotOn = autoScreenshotEnabled();
   let TOOLS_URL;
-  if (process.env.ARGENT_TOOLS_URL) {
-    TOOLS_URL = process.env.ARGENT_TOOLS_URL;
+  let AUTH_TOKEN;
+  const resolved = await getResolvedToolsUrl();
+  if (resolved.url) {
+    TOOLS_URL = resolved.url;
+    AUTH_TOKEN = resolved.token ?? "";
   } else {
     try {
-      TOOLS_URL = await ensureToolsServer(options.paths);
+      const handle = await ensureToolsServer(options.paths);
+      TOOLS_URL = handle.url;
+      AUTH_TOKEN = handle.token;
     } catch (err) {
       process.stderr.write(`[argent] Failed to start tools server: ${err}
 `);
       process.exit(1);
     }
   }
+  function authHeader() {
+    return AUTH_TOKEN ? { Authorization: `Bearer ${AUTH_TOKEN}` } : {};
+  }
   let reconnectPromise = null;
   async function reconnect() {
-    if (process.env.ARGENT_TOOLS_URL) return;
+    if (await isRemoteRouted()) return;
     if (!reconnectPromise) {
-      reconnectPromise = ensureToolsServer(options.paths).then((url) => {
-        TOOLS_URL = url;
+      reconnectPromise = ensureToolsServer(options.paths).then((handle) => {
+        TOOLS_URL = handle.url;
+        AUTH_TOKEN = handle.token;
       }).finally(() => {
         reconnectPromise = null;
       });
     }
     return reconnectPromise;
   }
-  const LOG_FILE2 = process.env.ARGENT_MCP_LOG ?? `${homedir2()}/.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 mkdir2(dirname(LOG_FILE2), { recursive: true });
+        await mkdir4(dirname2(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");
@@ -15836,7 +16152,9 @@ async function startMcpServer(options) {
     }
   }
   async function fetchTools() {
-    const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools`, reconnect);
+    const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools`, reconnect, {
+      init: { headers: authHeader() }
+    });
     const json = await res.json();
     return json.tools;
   }
@@ -15846,7 +16164,7 @@ async function startMcpServer(options) {
     const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools/${name}`, reconnect, {
       init: {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", ...authHeader() },
         body: JSON.stringify(args ?? {})
       },
       fetchTimeoutMs: meta2?.longRunning ? null : FETCH_TIMEOUT_MS
@@ -15897,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 = [
@@ -15951,14 +16278,17 @@ async function startMcpServer(options) {
     }
   });
   await server.connect(new StdioServerTransport());
-  if (!process.env.ARGENT_TOOLS_URL) {
+  if (!await isRemoteRouted()) {
     const HEALTH_INTERVAL_MS = 3e4;
     const healthInterval = setInterval(async () => {
       try {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), 3e3);
         try {
-          const res = await fetch(`${TOOLS_URL}/tools`, { signal: controller.signal });
+          const res = await fetch(`${TOOLS_URL}/tools`, {
+            signal: controller.signal,
+            headers: authHeader()
+          });
           if (!res.ok) throw new Error(`health check returned ${res.status}`);
         } finally {
           clearTimeout(timer);
@@ -15971,9 +16301,9 @@ 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" }).catch(() => {
+      fetch(`${TOOLS_URL}/shutdown`, { method: "POST", headers: authHeader() }).catch(() => {
       });
       setTimeout(() => process.exit(0), 5e3);
     });