@swmansion/argent 0.15.0 → 0.15.1-next.0

package/dist/mcp-server.mjs

@@ -2984,7 +2984,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve4.call(this, root, ref);
+      let _sch = resolve5.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;
@@ -3011,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 resolve4(root, ref) {
+    function resolve5(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3642,7 +3642,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve4(baseURI, relativeURI, options) {
+    function resolve5(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;
@@ -3900,7 +3900,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve4,
+      resolve: resolve5,
       resolveComponent,
       equal,
       serialize,
@@ -6891,7 +6891,7 @@ var require_dist = __commonJS({
 
 // ../argent-mcp/src/mcp-server.ts
 import { appendFile, mkdir as mkdir5 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
@@ -13701,12 +13701,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve4();
+        resolve5();
       } else {
-        this._stdout.once("drain", resolve4);
+        this._stdout.once("drain", resolve5);
       }
     });
   }
@@ -14304,7 +14304,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
+        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -14321,7 +14321,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -14399,7 +14399,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve4(parseResult.data);
+            resolve5(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -14660,12 +14660,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve4, interval);
+      const timeoutId = setTimeout(resolve5, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -15490,7 +15490,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -15501,7 +15501,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve4(port);
+        else resolve5(port);
       });
     });
     srv.on("error", reject);
@@ -15599,7 +15599,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -15636,7 +15636,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve4({ port: actualPort, pid }));
+        settle(() => resolve5({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -15942,9 +15942,115 @@ async function isRemoteRouted() {
 }
 
 // ../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 { createHash as createHash2, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import * as path3 from "node:path";
+
+// ../archive/src/index.ts
+import { execFile } from "node:child_process";
+import { rm, readdir as readdir2 } from "node:fs/promises";
+import { basename, dirname as dirname2, join as join3, posix, resolve as resolve2, sep } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var ArchiveError = class extends Error {
+};
+function createTarGzArgs(sourcePath, target) {
+  return ["-czf", target, "-C", dirname2(sourcePath), basename(sourcePath)];
+}
+async function createTarGzFile(sourcePath, tarPath) {
+  try {
+    await execFileAsync("tar", createTarGzArgs(sourcePath, tarPath));
+  } catch (err) {
+    await rm(tarPath, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+function normalizeTarMemberPath(memberPath) {
+  return memberPath.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function isSafeTarMember(memberPath, destDir) {
+  const normalized = normalizeTarMemberPath(memberPath);
+  if (!normalized || normalized === "." || normalized === "./") return false;
+  if (normalized.startsWith("/") || /^[A-Za-z]:[\\/]/.test(normalized)) return false;
+  const relative2 = posix.normalize(normalized);
+  if (relative2 === ".." || relative2.startsWith("../") || relative2.split("/").includes("..")) {
+    return false;
+  }
+  const root = resolve2(destDir);
+  const resolved = resolve2(destDir, relative2);
+  return resolved === root || resolved.startsWith(root + sep);
+}
+async function listTarMembers(tarPath) {
+  const { stdout } = await execFileAsync("tar", ["-tzf", tarPath]);
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isEscapingLinkTarget(target) {
+  if (target.startsWith("/") || /^[A-Za-z]:[\\/]/.test(target)) return true;
+  return posix.normalize(target.replace(/\\/g, "/")).split("/").includes("..");
+}
+async function assertSafeMemberTypes(tarPath) {
+  const { stdout } = await execFileAsync("tar", ["-tzvf", tarPath]);
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const type = line[0];
+    if (type === "-" || type === "d") continue;
+    if (type === "l") {
+      const parts = line.split(" -> ");
+      const target = parts.length === 2 ? parts[1].trim() : "";
+      if (parts.length !== 2 || !target || isEscapingLinkTarget(target)) {
+        throw new ArchiveError(
+          `Archive contains a symlink whose target could not be confirmed safe: "${line.trim()}".`
+        );
+      }
+      continue;
+    }
+    throw new ArchiveError(
+      `Archive contains an unsupported member type "${type}" (hardlink/device/\u2026) \u2014 refusing extraction.`
+    );
+  }
+}
+async function assertSafeArchive(tarPath, destDir) {
+  let members;
+  try {
+    members = await listTarMembers(tarPath);
+  } catch (err) {
+    throw new ArchiveError(
+      `Could not read archive: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (members.length === 0) {
+    throw new ArchiveError("Archive is empty.");
+  }
+  for (const member of members) {
+    if (!isSafeTarMember(member, destDir)) {
+      throw new ArchiveError(`Archive contains an unsafe path "${member}" \u2014 refusing extraction.`);
+    }
+  }
+  await assertSafeMemberTypes(tarPath);
+}
+async function resolveMember(destDir, expectedName) {
+  const entries = await readdir2(destDir);
+  if (entries.includes(expectedName)) {
+    return join3(destDir, expectedName);
+  }
+  const real = entries.filter((e) => !e.startsWith("._"));
+  if (real.length !== 1) {
+    throw new ArchiveError(
+      `Could not identify the extracted member (expected "${expectedName}", found ${real.length} entries).`
+    );
+  }
+  return join3(destDir, real[0]);
+}
+async function safeExtractTarGz(tarPath, destDir, expectedName) {
+  await assertSafeArchive(tarPath, destDir);
+  await execFileAsync("tar", ["-xzf", tarPath, "-C", destDir]);
+  return resolveMember(destDir, expectedName);
+}
+
+// ../argent-tools-client/src/file-inputs.ts
 var FILE_INPUT_MARKER = "__argentFileInput";
 var CLIENT_FILE_MARKER = "__argentClientFile";
 var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
@@ -15960,6 +16066,34 @@ function interpolatePath(template, args) {
   });
   return missing ? null : out;
 }
+async function tarball(sourcePath) {
+  const tarPath = path3.join(tmpdir(), `argent-upload-${randomUUID()}.tar.gz`);
+  await createTarGzFile(sourcePath, tarPath);
+  return tarPath;
+}
+function sha256File(filePath) {
+  return new Promise((resolve5, reject) => {
+    const hash = createHash2("sha256");
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve5(hash.digest("hex"))).on("error", reject);
+  });
+}
+async function uploadTar(tarPath, endpoint) {
+  const init = {
+    method: "POST",
+    headers: {
+      "content-type": "application/gzip",
+      ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
+    },
+    body: createReadStream(tarPath),
+    duplex: "half"
+  };
+  const res = await fetch(`${endpoint.url}/upload`, init);
+  if (!res.ok) {
+    throw new Error(`Upload to ${endpoint.url}/upload failed: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return json.uploadId;
+}
 async function prepareFileInputs(specs, args, opts) {
   if (!specs || specs.length === 0 || typeof args !== "object" || args === null) {
     return args;
@@ -15987,6 +16121,28 @@ async function prepareFileInputs(specs, args, opts) {
       } catch {
       }
     }
+    if (spec.kind === "tar-upload") {
+      const st = await stat(filePath).catch(() => null);
+      if (st) {
+        wire.size = st.size;
+        wire.mtimeMs = st.mtimeMs;
+      }
+      if (opts.uploadEndpoint && st) {
+        let tarPath = null;
+        try {
+          process.stderr.write(
+            `Uploading ${path3.basename(filePath)} to the remote tool-server...
+`
+          );
+          tarPath = await tarball(filePath);
+          wire.contentHash = await sha256File(tarPath);
+          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint);
+        } finally {
+          if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    }
     out = out ?? { ...record2 };
     out[spec.target] = wire;
   }
@@ -16034,13 +16190,10 @@ async function applyClientFileDirectives(result) {
 }
 
 // ../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 as createHash2 } from "node:crypto";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { mkdir as mkdir4, readFile as readFile4, rm as rm3, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, join as join5 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
 var ARTIFACT_MARKER = "__argentArtifact";
 function isArtifactHandle(value) {
   return !!value && typeof value === "object" && value[ARTIFACT_MARKER] === true && typeof value.id === "string" && typeof value.filename === "string";
@@ -16058,17 +16211,17 @@ function sanitizeSegment(segment) {
 }
 function projectSlug() {
   const cwd = process.cwd();
-  const hash = createHash2("sha1").update(cwd).digest("hex").slice(0, 6);
-  const name = sanitizeSegment(basename(cwd)) || "root";
+  const hash = createHash3("sha1").update(cwd).digest("hex").slice(0, 6);
+  const name = sanitizeSegment(basename3(cwd)) || "root";
   return `${name}-${hash}`;
 }
 function artifactsRoot() {
-  return process.env.ARGENT_ARTIFACTS_DIR ?? join3(tmpdir(), "argent-artifacts");
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join5(tmpdir2(), "argent-artifacts");
 }
 function artifactDir(deviceId) {
   const parts = [artifactsRoot(), projectSlug(), sessionId()];
   if (deviceId) parts.push(sanitizeSegment(deviceId));
-  return join3(...parts);
+  return join5(...parts);
 }
 async function resolveLocalFile(handle) {
   if (!handle.hostPath) return null;
@@ -16088,15 +16241,14 @@ async function resolveLocalFile(handle) {
   }
 }
 async function downloadAndExtractArchive(handle, data, dir) {
-  const tarball = join3(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  const tarball2 = join5(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
   try {
-    await writeFile4(tarball, data);
-    await execFileAsync("tar", ["-xzf", tarball, "-C", dir]);
-    return join3(dir, handle.filename);
+    await writeFile4(tarball2, data);
+    return await safeExtractTarGz(tarball2, dir, handle.filename);
   } catch {
     return null;
   } finally {
-    await rm(tarball, { force: true }).catch(() => {
+    await rm3(tarball2, { force: true }).catch(() => {
     });
   }
 }
@@ -16132,7 +16284,7 @@ async function materializeArtifacts(result, ctx) {
           return await downloadAndExtractArchive(value, data, dir);
         }
         if (value.size > 0 && data.length !== value.size) return null;
-        const downloadedPath = join3(dir, sanitizeSegment(value.filename));
+        const downloadedPath = join5(dir, sanitizeSegment(value.filename));
         await writeFile4(downloadedPath, data);
         if (value.mimeType.startsWith("image/")) {
           images.push({ localPath: downloadedPath, data, mimeType: value.mimeType });
@@ -17307,7 +17459,7 @@ function getUtf8ByteLength(value) {
 }
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
-import { createReadStream } from "node:fs";
+import { createReadStream as createReadStream2 } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline";
 var LRU_FILE_CONTENTS_CACHE = new error_tracking_exports.ReduceableCache(25);
 var LRU_FILE_CONTENTS_FS_READ_FAILED = new error_tracking_exports.ReduceableCache(20);
@@ -17381,8 +17533,8 @@ var PostHogSentryIntegration = class {
 
 // ../registry/src/artifacts.ts
 import { stat as stat3 } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { basename as basename2, extname } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { basename as basename4, extname } from "node:path";
 
 // ../registry/src/failure-codes.ts
 var FAILURE_CODES = {
@@ -17406,6 +17558,7 @@ var FAILURE_CODES = {
   TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
   TOOL_PLATFORM_NOT_IMPLEMENTED: "TOOL_PLATFORM_NOT_IMPLEMENTED",
   TOOL_DEPENDENCY_MISSING: "TOOL_DEPENDENCY_MISSING",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
   TOOLSERVER_UNHANDLED_REJECTION: "TOOLSERVER_UNHANDLED_REJECTION",
   TOOLSERVER_UNCAUGHT_EXCEPTION: "TOOLSERVER_UNCAUGHT_EXCEPTION",
   INSTALL_GLOBAL_PACKAGE_FAILED: "INSTALL_GLOBAL_PACKAGE_FAILED",
@@ -17478,6 +17631,7 @@ var FAILURE_CODES = {
   NATIVE_DEVTOOLS_FIND_VIEWS_ERROR: "NATIVE_DEVTOOLS_FIND_VIEWS_ERROR",
   NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING: "NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING",
   NATIVE_DEVTOOLS_WRONG_PLATFORM: "NATIVE_DEVTOOLS_WRONG_PLATFORM",
+  NATIVE_DEVTOOLS_NOT_INJECTABLE: "NATIVE_DEVTOOLS_NOT_INJECTABLE",
   NATIVE_DEVTOOLS_NOT_CONNECTED: "NATIVE_DEVTOOLS_NOT_CONNECTED",
   NATIVE_DEVTOOLS_RPC_TIMEOUT: "NATIVE_DEVTOOLS_RPC_TIMEOUT",
   NATIVE_DEVTOOLS_RPC_ERROR: "NATIVE_DEVTOOLS_RPC_ERROR",
@@ -17540,6 +17694,11 @@ var FAILURE_CODES = {
   NATIVE_PROFILER_NO_RUNNING_APPS: "NATIVE_PROFILER_NO_RUNNING_APPS",
   NATIVE_PROFILER_NO_RUNNING_USER_APPS: "NATIVE_PROFILER_NO_RUNNING_USER_APPS",
   NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS: "NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS",
+  NATIVE_PROFILER_MALLOC_DEGRADED_XCODE: "NATIVE_PROFILER_MALLOC_DEGRADED_XCODE",
+  NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE: "NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE",
+  NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED: "NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED",
+  NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND: "NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND",
+  NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS: "NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS",
   NATIVE_PROFILER_SESSION_ALREADY_RUNNING: "NATIVE_PROFILER_SESSION_ALREADY_RUNNING",
   NATIVE_PROFILER_XCTRACE_NO_PID: "NATIVE_PROFILER_XCTRACE_NO_PID",
   NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND: "NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND",
@@ -17562,6 +17721,8 @@ var FAILURE_CODES = {
   FLOW_NO_ACTIVE_RECORDING: "FLOW_NO_ACTIVE_RECORDING",
   FLOW_FILE_INVALID: "FLOW_FILE_INVALID",
   FLOW_ENTRY_UNRECOGNIZED: "FLOW_ENTRY_UNRECOGNIZED",
+  FLOW_E2E_HAS_PREREQUISITE: "FLOW_E2E_HAS_PREREQUISITE",
+  FLOW_DEVICE_RESOLUTION: "FLOW_DEVICE_RESOLUTION",
   PROFILER_QUERY_MODE_INVALID: "PROFILER_QUERY_MODE_INVALID",
   PROFILER_QUERY_REQUIRED_PARAM_MISSING: "PROFILER_QUERY_REQUIRED_PARAM_MISSING",
   PROFILER_DATA_NOT_LOADED: "PROFILER_DATA_NOT_LOADED",
@@ -17656,7 +17817,7 @@ var FAILURE_SIGNAL_NAME_SET = new Set(FAILURE_SIGNAL_NAMES);
 var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 
 // ../registry/src/registry.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../telemetry/src/events.ts
 var PLATFORMS = [
@@ -17886,11 +18047,44 @@ var ALLOWED = {
     uptime_ms: DURATION_MS,
     total_tool_calls: COUNT,
     ...FAILURE_SIGNAL
+  },
+  "lens:preview_opened": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    is_cli_session: bool,
+    platform: PLATFORM
+  },
+  "lens:round_completed": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    annotation_count: COUNT,
+    element_comment_count: COUNT,
+    skipped_comment_count: COUNT,
+    has_global_comment: bool,
+    inspector_used: bool,
+    offscreen_revealed: bool,
+    is_cli_session: bool,
+    had_parked_await: bool,
+    round_duration_ms: DURATION_MS,
+    platform: PLATFORM
+  },
+  "lens:round_abandoned": {
+    round: COUNT,
+    element_count: COUNT,
+    variant_count: COUNT,
+    had_parked_await: bool,
+    is_cli_session: bool,
+    platform: PLATFORM
+  },
+  "lens:cli_session_started": {
+    agent_choice_count: COUNT
   }
 };
 
 // ../telemetry/src/base-props.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../telemetry/src/cloud-agent-detect.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -18264,7 +18458,7 @@ var vendors_default = [
 var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 
 // ../telemetry/src/base-props.ts
-var SESSION_ID2 = randomUUID3();
+var SESSION_ID2 = randomUUID4();
 
 // ../telemetry/src/identity.ts
 import * as crypto2 from "node:crypto";
@@ -18596,14 +18790,17 @@ async function toMcpContent(result, outputHint, ctx, args) {
       }
       return legacyImageContent(rewritten, suppressImage);
     }
-    const blocks = [{ type: "text", text: JSON.stringify(rewritten, null, 2) }];
+    const blocks = [{ type: "text", text: stringifyForText(rewritten) }];
     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) }];
+  return [{ type: "text", text: stringifyForText(result) }];
+}
+function stringifyForText(value) {
+  return JSON.stringify(value ?? null, null, 2);
 }
 async function legacyImageContent(result, suppressImage) {
   if (result && typeof result === "object" && "url" in result) {
@@ -18663,35 +18860,71 @@ async function screenshotDiffToMcpContent(result, ctx) {
   blocks.push({ type: "text", text: result.summary });
   return blocks;
 }
+var STATUS_GLYPH = {
+  pass: "\u2713",
+  fail: "\u2717",
+  error: "\u2717",
+  skip: "\xB7"
+};
+function stepLabel(step) {
+  if (step.kind === "echo") return step.message ?? "";
+  if (step.kind === "run") return `run ${step.flow ?? ""}`.trim();
+  if (step.tool) return step.tool;
+  if (step.target) return `${step.kind} ${step.target}`;
+  return step.kind;
+}
 async function flowRunToMcpContent(result, ctx) {
   const blocks = [];
   if (result.executionPrerequisite) {
-    blocks.push({
-      type: "text",
-      text: `Prerequisite: ${result.executionPrerequisite}`
-    });
+    blocks.push({ type: "text", text: `Prerequisite: ${result.executionPrerequisite}` });
   }
   blocks.push({
     type: "text",
-    text: `Running flow "${result.flow}" (${result.steps.length} steps)`
+    text: `Running flow "${result.flow}"${result.device ? ` on ${result.device}` : ""} (${result.steps.length} steps)`
   });
   for (let i = 0; i < result.steps.length; i++) {
     const step = result.steps[i];
-    const num = i + 1;
-    if (step.kind === "echo") {
-      blocks.push({ type: "text", text: `[${num}] ${step.message}` });
-    } else if ("error" in step && step.error) {
-      blocks.push({
-        type: "text",
-        text: `[${num}] ${step.tool} ERROR: ${step.error}`
-      });
-    } else {
-      blocks.push({ type: "text", text: `[${num}] ${step.tool}` });
-      const stepContent = await toMcpContent(step.result, step.outputHint, ctx, step.args);
-      blocks.push(...stepContent);
+    const num = step.index !== void 0 ? step.index + 1 : i + 1;
+    const glyph = step.status ? `${STATUS_GLYPH[step.status] ?? "\u2022"} ` : "";
+    const reason = step.reason ?? step.error;
+    const suffix = reason ? ` \u2014 ${reason}` : "";
+    const warning = step.warning ? ` \u26A0 ${step.warning}` : "";
+    blocks.push({ type: "text", text: `[${num}] ${glyph}${stepLabel(step)}${suffix}${warning}` });
+    if (step.result !== void 0) {
+      blocks.push(...await toMcpContent(step.result, step.outputHint, ctx, step.args));
+    }
+    if (isRecord(step.artifacts)) {
+      blocks.push(...await stepArtifactBlocks(step.artifacts, step.status, ctx));
     }
   }
-  blocks.push({ type: "text", text: `Flow "${result.flow}" complete.` });
+  if (result.ok !== void 0) {
+    blocks.push({
+      type: "text",
+      text: `${result.ok ? "PASS" : "FAIL"} \u2014 ${result.passed ?? 0} passed, ${result.failed ?? 0} failed, ${result.errored ?? 0} errored, ${result.skipped ?? 0} skipped`
+    });
+  } else {
+    blocks.push({ type: "text", text: `Flow "${result.flow}" complete.` });
+  }
+  return blocks;
+}
+async function stepArtifactBlocks(artifacts, status, ctx) {
+  const failed = status === "fail" || status === "error";
+  const entries = [];
+  let diffImage;
+  for (const [k, v] of Object.entries(artifacts)) {
+    if (ctx && failed && k === "diff" && isArtifactHandle(v)) {
+      const { result, images } = await materializeArtifacts(v, ctx);
+      entries.push([k, typeof result === "string" ? result : "(unavailable)"]);
+      const img = images.find((i) => i.localPath === result);
+      if (img) diffImage = imageBlock(img.data, img.mimeType);
+    } else if (isArtifactHandle(v)) {
+      entries.push([k, v.hostPath ?? v.filename]);
+    } else if (typeof v === "string") {
+      entries.push([k, v]);
+    }
+  }
+  const blocks = entries.length > 0 ? [{ type: "text", text: entries.map(([k, v]) => `  ${k}: ${v}`).join("\n") }] : [];
+  if (diffImage) blocks.push(diffImage);
   return blocks;
 }
 
@@ -18867,7 +19100,7 @@ async function startMcpServer(options) {
   async function spyLog(entry) {
     try {
       if (!logDirReady) {
-        await mkdir5(dirname4(LOG_FILE2), { recursive: true });
+        await mkdir5(dirname5(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");