@swmansion/argent 0.16.2-next.8 → 0.17.0

package/dist/tool-server.cjs

@@ -109,7 +109,9 @@ var init_artifacts = __esm({
       ".xml": "application/xml",
       ".txt": "text/plain",
       ".md": "text/markdown",
-      ".html": "text/html"
+      ".html": "text/html",
+      ".mp4": "video/mp4",
+      ".mov": "video/quicktime"
     };
     ArtifactStore = class {
       entries = /* @__PURE__ */ new Map();
@@ -138,6 +140,7 @@ var init_artifacts = __esm({
         };
         if (mtimeMs != null) handle.mtimeMs = mtimeMs;
         if (isDirectory2) handle.archive = "tar.gz";
+        if (opts?.saveDir) handle.saveDir = opts.saveDir;
         return handle;
       }
       get(id) {
@@ -382,6 +385,7 @@ var init_failure_codes = __esm({
       SCREEN_RECORDING_NO_ACTIVE_SESSION: "SCREEN_RECORDING_NO_ACTIVE_SESSION",
       SCREEN_RECORDING_STOP_IN_PROGRESS: "SCREEN_RECORDING_STOP_IN_PROGRESS",
       SCREEN_RECORDING_START_EXITED: "SCREEN_RECORDING_START_EXITED",
+      SCREEN_RECORDING_START_TIMEOUT: "SCREEN_RECORDING_START_TIMEOUT",
       SCREEN_RECORDING_PROCESS_ERROR: "SCREEN_RECORDING_PROCESS_ERROR",
       SCREEN_RECORDING_OUTPUT_MISSING: "SCREEN_RECORDING_OUTPUT_MISSING",
       SCREEN_RECORDING_SERVER_SHUTTING_DOWN: "SCREEN_RECORDING_SERVER_SHUTTING_DOWN",
@@ -34931,7 +34935,7 @@ var require_view = __commonJS({
     var path38 = require("node:path");
     var fs50 = require("node:fs");
     var dirname14 = path38.dirname;
-    var basename9 = path38.basename;
+    var basename10 = path38.basename;
     var extname4 = path38.extname;
     var join46 = path38.join;
     var resolve7 = path38.resolve;
@@ -34970,7 +34974,7 @@ var require_view = __commonJS({
         var root2 = roots[i];
         var loc = resolve7(root2, name);
         var dir = dirname14(loc);
-        var file2 = basename9(loc);
+        var file2 = basename10(loc);
         path39 = this.resolve(dir, file2);
       }
       return path39;
@@ -35000,7 +35004,7 @@ var require_view = __commonJS({
       if (stat4 && stat4.isFile()) {
         return path39;
       }
-      path39 = join46(dir, basename9(file2, ext), "index" + ext);
+      path39 = join46(dir, basename10(file2, ext), "index" + ext);
       stat4 = tryStat(path39);
       if (stat4 && stat4.isFile()) {
         return path39;
@@ -57445,9 +57449,9 @@ var require_content_disposition = __commonJS({
       if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
         throw new TypeError("fallback must be ISO-8859-1 string");
       }
-      var name = basename9(filename);
+      var name = basename10(filename);
       var isQuotedString = TEXT_REGEXP.test(name);
-      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename9(fallback);
+      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename10(fallback);
       var hasFallback = typeof fallbackName === "string" && fallbackName !== name;
       if (hasFallback || !isQuotedString || hasHexEscape(name)) {
         params["filename*"] = name;
@@ -57567,7 +57571,7 @@ var require_content_disposition = __commonJS({
       this.type = type;
       this.parameters = parameters;
     }
-    function basename9(path38) {
+    function basename10(path38) {
       const normalized = path38.replaceAll("\\", "/");
       let end = normalized.length;
       while (end > 0 && normalized[end - 1] === "/") {
@@ -104489,7 +104493,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.16.1";
+    return "0.17.0";
   }
   return "0.0.0";
 }
@@ -105877,7 +105881,7 @@ var import_node_path5 = __toESM(require("node:path"));
 var import_semver = __toESM(require_semver2());
 
 // ../tool-server/package.json
-var version3 = "0.16.1";
+var version3 = "0.17.0";
 
 // ../tool-server/src/utils/update-checker.ts
 var import_update_core = __toESM(require_dist4());
@@ -114038,6 +114042,27 @@ function sendCommand(api, cmd) {
     ws.once("open", () => ws.send(payload));
   }
 }
+function setPointerVisible(api, show, signal) {
+  return pointerPost(api, { show }, signal);
+}
+function setPointerTrail(api, trail, signal) {
+  return pointerPost(api, { trail }, signal);
+}
+async function pointerPost(api, body, signal) {
+  try {
+    const res = await fetch(`${api.apiUrl}/api/pointer`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!res.ok) return false;
+    const parsed = await res.json().catch(() => null);
+    return parsed?.status === "ok";
+  } catch {
+    return false;
+  }
+}
 async function simulatorPost(toolLabel, api, endpoint, reqBody, signal, fallbackHint) {
   let res;
   try {
@@ -142986,6 +143011,8 @@ function clearLiveState2(state3) {
   state3.pendingChild = null;
   state3.frameStream = null;
   state3.lastFrameStreamError = null;
+  state3.pointerDisable = null;
+  state3.pointerFailed = false;
   state3.recordingTimedOut = false;
   state3.recordingExitedUnexpectedly = false;
   state3.lastExitInfo = null;
@@ -143036,6 +143063,11 @@ var screenRecordingSessionBlueprint = {
       frameStream: null,
       lastFrameStreamError: null,
       pumpTimer: null,
+      trimStatic: true,
+      framesWritten: 0,
+      trimmedAnyFrames: false,
+      pointerDisable: null,
+      pointerFailed: false,
       wallClockStartMs: null,
       wallClockEndMs: null,
       timeLimitSeconds: null,
@@ -143058,6 +143090,12 @@ var screenRecordingSessionBlueprint = {
           state3.pumpTimer = null;
         }
         state3.frameStream?.close();
+        if (state3.pointerDisable) {
+          const disable = state3.pointerDisable;
+          state3.pointerDisable = null;
+          await disable().catch(() => {
+          });
+        }
         if (state3.pendingChild) {
           try {
             state3.pendingChild.kill("SIGKILL");
@@ -143486,6 +143524,7 @@ var OUTPUT_FPS2 = 30;
 var FRAME_INTERVAL_MS = 1e3 / OUTPUT_FPS2;
 var MAX_CATCHUP_FRAMES = 5;
 var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+var STATIC_GRACE_MS = 1e3;
 var STREAM_CONNECT_TIMEOUT_MS = 1e4;
 var FIRST_FRAME_TIMEOUT_MS = 1e4;
 var START_FAILFAST_GRACE_MS = 800;
@@ -143542,24 +143581,59 @@ function ffmpegArgs(opts) {
 function framesDue(startedAtMs, nowMs) {
   return Math.floor((nowMs - startedAtMs) * OUTPUT_FPS2 / 1e3);
 }
+function sameFrame(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.equals(b);
+}
 function startPump(api, stream) {
   const child = api.captureProcess;
-  const startedAt = api.wallClockStartMs ?? Date.now();
-  let written = 0;
+  const trim = api.trimStatic;
+  api.framesWritten = 0;
+  api.trimmedAnyFrames = false;
+  let paceBaseMs = api.wallClockStartMs ?? Date.now();
+  let paceBaseFrames = 0;
+  let lastFrame = null;
+  let lastChangeMs = paceBaseMs;
+  let dead = false;
   api.pumpTimer = setInterval(() => {
     const stdin = child?.stdin;
     if (!stdin || !stdin.writable) return;
     const frame = stream.latest;
     if (!frame) return;
     if (stdin.writableLength > MAX_BUFFERED_BYTES) return;
-    const missing = Math.min(framesDue(startedAt, Date.now()) - written, MAX_CATCHUP_FRAMES);
+    const now = Date.now();
+    if (trim) {
+      if (!sameFrame(frame, lastFrame)) {
+        lastFrame = frame;
+        lastChangeMs = now;
+      }
+      if (now - lastChangeMs > STATIC_GRACE_MS) {
+        dead = true;
+        api.trimmedAnyFrames = true;
+        return;
+      }
+      if (dead) {
+        dead = false;
+        paceBaseMs = now;
+        paceBaseFrames = api.framesWritten;
+      }
+    }
+    const target = paceBaseFrames + framesDue(paceBaseMs, now);
+    const missing = Math.min(target - api.framesWritten, MAX_CATCHUP_FRAMES);
     for (let i = 0; i < missing; i++) {
       if (!stdin.writable) return;
       stdin.write(frame);
-      written++;
+      api.framesWritten++;
     }
   }, FRAME_INTERVAL_MS);
 }
+async function disablePointer(api) {
+  const disable = api.pointerDisable;
+  api.pointerDisable = null;
+  if (disable) await disable().catch(() => {
+  });
+}
 function stopPump(api) {
   if (api.pumpTimer) {
     clearInterval(api.pumpTimer);
@@ -143654,11 +143728,14 @@ async function startCaptureLocked(api, params) {
   api.recordingTimedOut = false;
   api.recordingExitedUnexpectedly = false;
   api.pendingRetrieval = false;
+  api.pointerFailed = false;
   api.lastExitInfo = null;
   api.lastFrameStreamError = null;
   api.outputFile = outputFile;
   api.logoFile = logoFile;
   api.watermarkSkipped = watermarkSkipped;
+  api.trimStatic = params.trimStatic;
+  api.framesWritten = 0;
   api.captureProcess = child;
   api.frameStream = stream;
   api.recordingActive = true;
@@ -143667,16 +143744,6 @@ async function startCaptureLocked(api, params) {
   api.timeLimitSeconds = params.timeLimitSeconds;
   registerActiveScreenRecording(api.deviceId, api.wallClockStartMs, params.timeLimitSeconds);
   startPump(api, stream);
-  api.recordingTimeout = setTimeout(() => {
-    api.recordingTimeout = null;
-    if (api.captureProcess !== child) return;
-    api.recordingTimedOut = true;
-    api.recordingActive = false;
-    api.wallClockEndMs = Date.now();
-    api.pendingRetrieval = true;
-    markScreenRecordingFinalized(api.deviceId, `it hit its ${params.timeLimitSeconds}s time limit`);
-    finalizeCapture(api);
-  }, params.timeLimitSeconds * 1e3);
   child.on("exit", (code, signal) => {
     if (api.captureProcess !== child) return;
     api.lastExitInfo = { code, signal };
@@ -143691,9 +143758,25 @@ async function startCaptureLocked(api, params) {
       api.wallClockEndMs = Date.now();
       api.pendingRetrieval = true;
       stopPump(api);
+      void disablePointer(api);
       markScreenRecordingFinalized(api.deviceId, "the recording process exited unexpectedly");
     }
   });
+  if (params.pointer) {
+    api.pointerDisable = params.pointer.disable;
+    api.pointerFailed = !await params.pointer.enable();
+  }
+  api.recordingTimeout = setTimeout(() => {
+    api.recordingTimeout = null;
+    if (api.captureProcess !== child) return;
+    api.recordingTimedOut = true;
+    api.recordingActive = false;
+    api.wallClockEndMs = Date.now();
+    api.pendingRetrieval = true;
+    markScreenRecordingFinalized(api.deviceId, `it hit its ${params.timeLimitSeconds}s time limit`);
+    finalizeCapture(api);
+    void disablePointer(api);
+  }, params.timeLimitSeconds * 1e3);
   return {
     status: "recording",
     timeLimitSeconds: params.timeLimitSeconds,
@@ -143756,9 +143839,11 @@ async function stopCapture(api) {
   const outputFile = api.outputFile;
   const logoFile = api.logoFile;
   const startedAtMs = api.wallClockStartMs;
+  const trimStatic = api.trimStatic;
   const endedEarly = api.recordingTimedOut || api.recordingExitedUnexpectedly;
   const streamError = api.frameStream?.error ?? api.lastFrameStreamError ?? null;
   const watermarkSkipped = api.watermarkSkipped;
+  const pointerFailed = api.pointerFailed;
   let warning;
   try {
     const child = api.captureProcess;
@@ -143792,9 +143877,23 @@ async function stopCapture(api) {
     if (watermarkSkipped) {
       warning = [warning, `The watermark was not applied (${watermarkSkipped}).`].filter(Boolean).join(" ");
     }
+    if (pointerFailed) {
+      warning = [
+        warning,
+        "The touch visualizer could not be enabled on simulator-server, so touches are not shown in this video."
+      ].filter(Boolean).join(" ");
+    }
     const size = await statNonEmptyOutput(outputFile, "screen_recording_stop");
-    const durationMs = startedAtMs === null ? null : (api.wallClockEndMs ?? Date.now()) - startedAtMs;
-    return { outputFile, sizeBytes: size, durationMs, ...warning ? { warning } : {} };
+    const wallClockMs = startedAtMs === null ? null : (api.wallClockEndMs ?? Date.now()) - startedAtMs;
+    const durationMs = trimStatic ? Math.round(api.framesWritten / OUTPUT_FPS2 * 1e3) : wallClockMs;
+    const trimmedMs = trimStatic && wallClockMs !== null && api.trimmedAnyFrames ? Math.max(0, wallClockMs - durationMs) : void 0;
+    return {
+      outputFile,
+      sizeBytes: size,
+      durationMs,
+      ...trimmedMs !== void 0 ? { wallClockMs, trimmedMs } : {},
+      ...warning ? { warning } : {}
+    };
   } catch (err) {
     const empty2 = await import_fs17.promises.stat(outputFile).then((s) => s.size === 0).catch(() => false);
     if (empty2) await import_fs17.promises.rm(outputFile, { force: true }).catch(() => {
@@ -143802,6 +143901,7 @@ async function stopCapture(api) {
     throw err;
   } finally {
     stopPump(api);
+    await disablePointer(api);
     api.recordingActive = false;
     api.stopPending = false;
     api.pendingRetrieval = false;
@@ -143809,6 +143909,9 @@ async function stopCapture(api) {
     api.outputFile = null;
     api.logoFile = null;
     api.watermarkSkipped = null;
+    api.pointerFailed = false;
+    api.framesWritten = 0;
+    api.trimmedAnyFrames = false;
     api.wallClockStartMs = null;
     api.wallClockEndMs = null;
     api.timeLimitSeconds = null;
@@ -143825,10 +143928,18 @@ async function stopCapture(api) {
 // ../tool-server/src/tools/screen-recording/screen-recording-start.ts
 var DEFAULT_TIME_LIMIT_SECONDS = 180;
 var MAX_TIME_LIMIT_SECONDS = 600;
+var POINTER_TRAIL_LENGTH = 8;
+var POINTER_REQUEST_TIMEOUT_MS = 2e3;
 var zodSchema51 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS Simulator UDID or Android serial)."),
   timeLimitSeconds: external_exports.number().int().min(1).max(MAX_TIME_LIMIT_SECONDS).optional().describe(
     `Auto-stop cap in seconds (default ${DEFAULT_TIME_LIMIT_SECONDS}, max ${MAX_TIME_LIMIT_SECONDS}). Set it to slightly more than the interaction you plan to capture.`
+  ),
+  trimStatic: external_exports.boolean().optional().describe(
+    "Default true. Collapse stretches where the screen does not change: the first second of each still stretch is kept, then unchanged frames are dropped until something moves again, so a long recording with brief activity comes back short instead of full of dead air. The returned durationMs is the trimmed length; wallClockMs/trimmedMs report what was removed. Set false to keep a faithful real-time recording."
+  ),
+  showTouches: external_exports.boolean().optional().describe(
+    "Default true. Draw simulator-server's touch visualizer into the recording: a pulse marks each tap, a comet trail follows swipes and drags, and paired markers show two-finger pinch/rotate, so the video makes clear where every interaction landed. Set false to record the raw screen with no overlay."
   )
 });
 var capability26 = {
@@ -143839,7 +143950,9 @@ function createScreenRecordingStartTool(registry2) {
   return {
     id: "screen-recording-start",
     capability: capability26,
-    description: `Start recording the device screen to a video file (h264 mp4, constant 30fps at the device's native resolution).
+    description: `Start recording the device screen to a video file (h264 mp4, 30fps at the device's native resolution).
+By default stretches where the screen does not change are trimmed out (see trimStatic), so a long session with only brief activity comes back as a short clip instead of minutes of dead air.
+By default every tap, swipe, drag, pinch and rotate is drawn into the video as an on-screen touch marker (see showTouches), so the recording shows where each interaction landed.
 The recording keeps running across other tool calls (every result carries a reminder) until \`screen-recording-stop\` is called or timeLimitSeconds elapses \u2014 immediately after starting, set yourself a reminder/wakeup for the expected end of the recording so it is never left running.
 Use when the user wants a video of an interaction, animation, or app behavior \u2014 for a single still frame use \`screenshot\` instead.
 Returns { status: "recording", timeLimitSeconds, outputFile } \u2014 the video is retrieved later by \`screen-recording-stop\`, not by reading outputFile directly.
@@ -143884,20 +143997,53 @@ Fails if a recording is already running on the device, the device is not booted,
           }
         );
       }
+      const showTouches = params.showTouches ?? true;
+      const pointer = showTouches ? makePointerControl(simulator) : void 0;
       return startCapture(api, {
         streamUrl,
         timeLimitSeconds,
-        watermark: isFeatureEnabled("video-watermark")
+        watermark: isFeatureEnabled("video-watermark"),
+        trimStatic: params.trimStatic ?? true,
+        pointer
+      });
+    }
+  };
+}
+function makePointerControl(simulator) {
+  let enabling = null;
+  return {
+    async enable() {
+      const run2 = (async () => {
+        await setPointerTrail(
+          simulator,
+          POINTER_TRAIL_LENGTH,
+          AbortSignal.timeout(POINTER_REQUEST_TIMEOUT_MS)
+        );
+        return setPointerVisible(simulator, true, AbortSignal.timeout(POINTER_REQUEST_TIMEOUT_MS));
+      })();
+      enabling = run2;
+      try {
+        return await run2;
+      } finally {
+        if (enabling === run2) enabling = null;
+      }
+    },
+    async disable() {
+      const pending = enabling;
+      if (pending) await pending.catch(() => {
       });
+      await setPointerVisible(simulator, false, AbortSignal.timeout(POINTER_REQUEST_TIMEOUT_MS));
     }
   };
 }
 
 // ../tool-server/src/tools/screen-recording/screen-recording-stop.ts
+var import_node_path20 = require("node:path");
 init_zod();
 var zodSchema52 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS Simulator UDID or Android serial).")
 });
+var RECORDINGS_DIR = ".argent/recordings";
 var capability27 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
@@ -143908,7 +144054,7 @@ var screenRecordingStopTool = {
   description: `Stop the screen recording started by \`screen-recording-start\` and retrieve the video: frame capture ends and ffmpeg finalizes the mp4.
 Also retrieves the video when the recording already ended on its own (time limit reached, capture process died) \u2014 call it even after the cap fired.
 Use when the interaction being captured is finished, or a tool-result note reminds you a recording is still running.
-Returns { video, durationMs, warning? }; video is a downloadable artifact materialized to a local path.
+Returns { video, durationMs, wallClockMs?, trimmedMs?, warning? }; video is a downloadable artifact materialized to a local path. When static-frame trimming removed dead air, durationMs is the trimmed video length and wallClockMs/trimmedMs report the real duration and how much was cut.
 Fails if no recording (running or finished-but-unretrieved) exists for the given udid.`,
   searchHint: "stop end finish screen recording video capture save retrieve",
   zodSchema: zodSchema52,
@@ -143921,8 +144067,16 @@ Fails if no recording (running or finished-but-unretrieved) exists for the given
     assertSupported("screen-recording-stop", capability27, device);
     const stopped = await stopCapture(api);
     const artifacts = requireArtifacts(ctx);
-    const video = await artifacts.register(stopped.outputFile, { mimeType: "video/mp4" });
+    const video = await artifacts.register(stopped.outputFile, {
+      mimeType: "video/mp4",
+      // Drop the internal `argent-` temp prefix so the saved file reads cleanly
+      // as `.argent/recordings/screen-recording-<device>-<ts>.mp4`.
+      filename: (0, import_node_path20.basename)(stopped.outputFile).replace(/^argent-/, ""),
+      saveDir: RECORDINGS_DIR
+    });
     const result = { video, durationMs: stopped.durationMs };
+    if (stopped.wallClockMs !== void 0) result.wallClockMs = stopped.wallClockMs;
+    if (stopped.trimmedMs !== void 0) result.trimmedMs = stopped.trimmedMs;
     if (stopped.warning) result.warning = stopped.warning;
     return result;
   }
@@ -150941,7 +151095,7 @@ init_zod();
 
 // ../tool-server/src/utils/workspace-reader.ts
 var import_promises12 = require("node:fs/promises");
-var import_node_path20 = require("node:path");
+var import_node_path21 = require("node:path");
 var import_node_child_process27 = require("node:child_process");
 var import_dotenv = __toESM(require_main());
 async function exists(path38) {
@@ -151029,7 +151183,7 @@ async function detectLockfile(workspacePath) {
   const checks = await Promise.all(
     LOCKFILES.map(async (name) => ({
       name,
-      exists: await exists((0, import_node_path20.join)(workspacePath, name))
+      exists: await exists((0, import_node_path21.join)(workspacePath, name))
     }))
   );
   return checks.find((c) => c.exists)?.name ?? null;
@@ -151048,7 +151202,7 @@ var CI_CONFIGS = [
 ];
 async function detectCiConfig(workspacePath) {
   for (const ci of CI_CONFIGS) {
-    if (await exists((0, import_node_path20.join)(workspacePath, ci.path))) return ci.label;
+    if (await exists((0, import_node_path21.join)(workspacePath, ci.path))) return ci.label;
   }
   return null;
 }
@@ -151069,7 +151223,7 @@ async function detectLintStagedConfig(workspacePath, packageJson) {
     return packageJson["lint-staged"];
   }
   for (const file2 of LINT_STAGED_FILES) {
-    const full = (0, import_node_path20.join)(workspacePath, file2);
+    const full = (0, import_node_path21.join)(workspacePath, file2);
     if (await exists(full)) {
       if (file2.endsWith(".json") || file2 === ".lintstagedrc") {
         return readJsonFile(full);
@@ -151111,7 +151265,7 @@ var CONFIG_FILES = [
 async function detectConfigFiles(workspacePath) {
   const results = await Promise.allSettled(
     CONFIG_FILES.map(async (file2) => {
-      if (await exists((0, import_node_path20.join)(workspacePath, file2))) return file2;
+      if (await exists((0, import_node_path21.join)(workspacePath, file2))) return file2;
       return null;
     })
   );
@@ -151150,7 +151304,7 @@ async function detectEnvFiles(workspacePath) {
   const envFileNames = entries.filter((e) => e === ".env" || e.startsWith(".env."));
   const results = await Promise.all(
     envFileNames.map(async (name) => {
-      const content = await readTextFile((0, import_node_path20.join)(workspacePath, name));
+      const content = await readTextFile((0, import_node_path21.join)(workspacePath, name));
       return {
         name,
         keys: content ? extractEnvKeys(content) : []
@@ -151177,34 +151331,34 @@ async function readWorkspaceSnapshot(workspacePath) {
     ciConfig,
     configFilesFound
   ] = await Promise.all([
-    readJsonFile((0, import_node_path20.join)(workspacePath, "package.json")),
-    readJsonFile((0, import_node_path20.join)(workspacePath, "app.json")),
-    readJsonFile((0, import_node_path20.join)(workspacePath, "eas.json")),
-    readJsonFile((0, import_node_path20.join)(workspacePath, "tsconfig.json")),
-    readTextFile((0, import_node_path20.join)(workspacePath, "metro.config.js")).then(
-      (r) => r ?? readTextFile((0, import_node_path20.join)(workspacePath, "metro.config.ts"))
+    readJsonFile((0, import_node_path21.join)(workspacePath, "package.json")),
+    readJsonFile((0, import_node_path21.join)(workspacePath, "app.json")),
+    readJsonFile((0, import_node_path21.join)(workspacePath, "eas.json")),
+    readJsonFile((0, import_node_path21.join)(workspacePath, "tsconfig.json")),
+    readTextFile((0, import_node_path21.join)(workspacePath, "metro.config.js")).then(
+      (r) => r ?? readTextFile((0, import_node_path21.join)(workspacePath, "metro.config.ts"))
     ),
-    readTextFile((0, import_node_path20.join)(workspacePath, "babel.config.js")).then(
-      (r) => r ?? readTextFile((0, import_node_path20.join)(workspacePath, "babel.config.cjs"))
+    readTextFile((0, import_node_path21.join)(workspacePath, "babel.config.js")).then(
+      (r) => r ?? readTextFile((0, import_node_path21.join)(workspacePath, "babel.config.cjs"))
     ),
-    isDirectory((0, import_node_path20.join)(workspacePath, "ios")),
-    isDirectory((0, import_node_path20.join)(workspacePath, "android")),
+    isDirectory((0, import_node_path21.join)(workspacePath, "ios")),
+    isDirectory((0, import_node_path21.join)(workspacePath, "android")),
     detectLockfile(workspacePath),
     detectEnvFiles(workspacePath),
     detectToolVersions(workspacePath),
-    listDir((0, import_node_path20.join)(workspacePath, "scripts")),
-    listDir((0, import_node_path20.join)(workspacePath, ".husky")),
+    listDir((0, import_node_path21.join)(workspacePath, "scripts")),
+    listDir((0, import_node_path21.join)(workspacePath, ".husky")),
     detectCiConfig(workspacePath),
     detectConfigFiles(workspacePath)
   ]);
-  const iosDir = (0, import_node_path20.join)(workspacePath, "ios");
-  const androidDir = (0, import_node_path20.join)(workspacePath, "android");
+  const iosDir = (0, import_node_path21.join)(workspacePath, "ios");
+  const androidDir = (0, import_node_path21.join)(workspacePath, "android");
   const [iosWorkspace, iosHasPodfile, makefileText, lintStagedConfig, androidHasGradle] = await Promise.all([
     hasIosDir ? findIosWorkspace(iosDir) : Promise.resolve(null),
-    exists((0, import_node_path20.join)(workspacePath, "ios", "Podfile")),
-    readTextFile((0, import_node_path20.join)(workspacePath, "Makefile")),
+    exists((0, import_node_path21.join)(workspacePath, "ios", "Podfile")),
+    readTextFile((0, import_node_path21.join)(workspacePath, "Makefile")),
     detectLintStagedConfig(workspacePath, packageJson),
-    hasAndroidDir ? exists((0, import_node_path20.join)(androidDir, "gradlew")) : Promise.resolve(false)
+    hasAndroidDir ? exists((0, import_node_path21.join)(androidDir, "gradlew")) : Promise.resolve(false)
   ]);
   const metroPort = metroConfigRaw ? extractMetroPort(metroConfigRaw) : null;
   const makefileTargets = makefileText ? extractMakefileTargets(makefileText) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.16.2-next.8",
+  "version": "0.17.0",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {

package/skills/argent-screen-recording/SKILL.md

@@ -14,7 +14,7 @@ One recording per device at a time; different devices can record concurrently. R
 
 ## 2. Critical: never leave a recording running
 
-A recording does not stop itself before its `timeLimitSeconds` cap, and a forgotten one wastes disk and returns a video full of dead air. Two safety nets exist — use both:
+A recording does not stop itself before its `timeLimitSeconds` cap, so a forgotten one keeps capturing until the cap fires — holding the recording session, wasting disk, and delaying the video you are waiting on (and with `trimStatic: false` it comes back padded with dead air). Two safety nets exist — use both:
 
 1. **Set yourself a reminder the moment the recording starts.** You know the expected capture length (the interaction you are about to drive). Immediately after `screen-recording-start` returns, schedule a wake-up for that expected end time using whatever your harness provides — a built-in reminder/wakeup or scheduled-task tool if you have one, otherwise a background shell running `sleep <expected-seconds>` whose completion notification pulls you back. When it fires, call `screen-recording-stop`. Do not rely on remembering.
 2. **Read the tool-result notes.** While a recording is running, every argent tool result carries a `NOTE:` reminding you it is still going and how to stop it. If the note says the recording already ended (time limit hit), still call `screen-recording-stop` — that is what hands you the file.
@@ -24,18 +24,24 @@ A recording does not stop itself before its `timeLimitSeconds` cap, and a forgot
 ## 3. Workflow
 
 1. Ensure the target device is booted and the app is in the state you want the video to open on (`list-devices`, `launch-app`, `argent-device-interact`).
-2. Call `screen-recording-start` with `udid` and a `timeLimitSeconds` slightly above the expected interaction length (default 180, max 600).
+2. Call `screen-recording-start` with `udid` and a `timeLimitSeconds` slightly above the expected interaction length (default 180, max 600). Taps and swipes are drawn into the video by default (see the touch-visualizer note below); pass `showTouches: false` for a clean raw-screen capture.
 3. Set the end-of-recording reminder described in §2 — this step is not optional.
 4. Drive the interaction to capture: gestures, navigation, typing (`argent-device-interact`). Prefer `run-sequence` for tight multi-step interactions so tool-call latency does not pad the video.
-5. Call `screen-recording-stop` with the same `udid`. It returns `{ video, durationMs, warning? }`; `video` is an artifact — use its `hostPath` locally or download it via the artifacts endpoint. The video is already final when stop returns (the watermark is stamped during capture, not in a second pass), so stop takes well under a second.
+5. Call `screen-recording-stop` with the same `udid`. It returns `{ video, durationMs, wallClockMs?, trimmedMs?, warning? }`; `video` is an artifact whose resolved path points at the durably-saved file (see below). The video is already final when stop returns (the watermark is stamped during capture, not in a second pass), so stop takes well under a second.
 6. Check `warning`: it reports cap-triggered stops, early encoder exits, a dropped frame stream, and possibly-truncated containers. Verify the file plays (or at least has a sane size) before presenting it to the user.
 
+**Where the file lands (durable, not scratch).** Unlike most argent artifacts (which live in a disposable temp cache the OS reclaims), a finished recording is saved durably on the **client** into `<project>/.argent/recordings/` — the project being the nearest ancestor of the client's working directory with a `.git`/`package.json`/`.argent`, or `~/.argent/recordings/` when the client isn't inside a project. This holds even for a remote `argent link` tool-server: the mp4 is written on the client host, not the server. The saved name is `screen-recording-<device>-<timestamp>.mp4`; if that name is already taken the new file lands beside it as `… (2).mp4` rather than overwriting. Because these files persist in the working tree, mention the path to the user (and note that they are untracked — add them to `.gitignore` or clean them up if they shouldn't be committed).
+
+**Static-frame trimming (on by default).** Stretches where the screen does not change are collapsed: the first second of each still stretch is kept so pauses read naturally, then unchanged frames are dropped until something moves again (a change of even a couple of pixels counts). So you can leave a recording running across slow steps, waits, or thinking time without padding the clip with dead air — a 40-second session with 5 seconds of real activity comes back as a ~5-7 second video. When trimming removed anything, stop also returns `wallClockMs` (real elapsed time) and `trimmedMs` (how much was cut); `durationMs` is always the length of the video you actually get. Pass `trimStatic: false` to `screen-recording-start` when you want a faithful real-time recording (e.g. to measure how long something took on screen).
+
+**Touch visualizer (on by default).** Every interaction argent drives is drawn straight into the video: a pulse marks each tap, a fading comet trail follows swipes and drags, and paired markers show the two contact points of a pinch or rotate. This makes a recording self-explanatory — a viewer can see _where_ each gesture landed rather than watching the UI react to an invisible finger. It is rendered by simulator-server into the frame stream (nothing is composited host-side), so it costs nothing extra and never appears in a `screenshot`. Pass `showTouches: false` to `screen-recording-start` to record the raw screen with no overlay (e.g. when capturing exactly what the user would see). If simulator-server cannot enable it, the recording still succeeds and stop returns a `warning` saying touches are not shown.
+
 ---
 
 ## 4. Platform notes and limits
 
 - **What can be recorded**: anything simulator-server drives — iOS simulators, Android emulators, and physical Android devices. The only length limit is `timeLimitSeconds` (max 600).
-- **The timeline is wall-clock accurate**: a device only emits a frame when its screen changes, so captured frames are re-paced onto a steady 30 fps timeline. A recording of a completely still screen is still a full-length video (and compresses to almost nothing), and `durationMs` matches the time you actually recorded.
+- **The timeline is paced to a steady 30 fps**: a device only emits a frame when its screen changes, so captured frames are re-paced onto a fixed timeline rather than bunching up. With static-frame trimming off (`trimStatic: false`) that timeline is wall-clock accurate — a completely still screen still comes back as a full-length video (compressing to almost nothing) and `durationMs` matches the time you actually recorded. With trimming on (the default, see §3) still stretches past the grace window are collapsed, so `durationMs` is the trimmed video length and `wallClockMs` carries the real elapsed time.
 - **Android**: records at the device's native resolution; secure screens (DRM, some password fields) come out black.
 - **Unsupported**: tvOS simulators, physical iPhones, Chromium apps, Vega/Fire TV, and remote (`remote:`-prefixed) simulators — none of them expose a readable frame stream. For a single still frame use `screenshot`; for a replayable interaction script use `argent-create-flow` instead of a video.
 - **ffmpeg is required**: it is the encoder, so `screen-recording-start` fails up front with an install hint if it is missing (`brew install ffmpeg`). It is resolved from `PATH` plus the usual Homebrew prefixes.