@swmansion/argent 0.8.1 → 0.9.0

package/dist/installer.mjs

@@ -9459,6 +9459,291 @@ var require_dist = __commonJS({
   }
 });
 
+// ../update-core/dist/config-parse.js
+var require_config_parse = __commonJS({
+  "../update-core/dist/config-parse.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DAY_MS = exports.MINUTE_MS = exports.SECOND_MS = void 0;
+    exports.parseConfigValue = parseConfigValue;
+    exports.parseBeforeAgeMs = parseBeforeAgeMs;
+    exports.parseYarnAgeGateMs = parseYarnAgeGateMs;
+    exports.SECOND_MS = 1e3;
+    exports.MINUTE_MS = 60 * 1e3;
+    exports.DAY_MS = 24 * 60 * 60 * 1e3;
+    function trimConfigValue(stdout) {
+      const trimmed = stdout.trim();
+      if (!trimmed || trimmed === "undefined" || trimmed === "null")
+        return null;
+      if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1).trim();
+      }
+      return trimmed;
+    }
+    function parseConfigValue(stdout) {
+      const value = trimConfigValue(stdout);
+      if (!value)
+        return 0;
+      const n = Number(value);
+      return Number.isFinite(n) && n > 0 ? n : 0;
+    }
+    function parseBeforeAgeMs(stdout, now = Date.now()) {
+      const value = trimConfigValue(stdout);
+      if (!value)
+        return 0;
+      const candidates = [value, value.replace(/\s+\([^)]*\)$/, "")];
+      for (const candidate of candidates) {
+        const ts = Date.parse(candidate);
+        if (!Number.isNaN(ts)) {
+          return ts < now ? now - ts : 0;
+        }
+      }
+      return 0;
+    }
+    function parseYarnAgeGateMs(stdout) {
+      const value = trimConfigValue(stdout);
+      if (!value)
+        return 0;
+      const numeric = Number(value);
+      if (Number.isFinite(numeric) && numeric > 0) {
+        return numeric * exports.MINUTE_MS;
+      }
+      const match = value.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/i);
+      if (!match)
+        return 0;
+      const amount = Number(match[1]);
+      if (!Number.isFinite(amount) || amount <= 0)
+        return 0;
+      switch (match[2].toLowerCase()) {
+        case "ms":
+          return amount;
+        case "s":
+          return amount * exports.SECOND_MS;
+        case "m":
+          return amount * exports.MINUTE_MS;
+        case "h":
+          return amount * 60 * exports.MINUTE_MS;
+        case "d":
+          return amount * exports.DAY_MS;
+        case "w":
+          return amount * 7 * exports.DAY_MS;
+        default:
+          return 0;
+      }
+    }
+  }
+});
+
+// ../update-core/dist/min-release-age.js
+var require_min_release_age = __commonJS({
+  "../update-core/dist/min-release-age.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.detectMinReleaseAgeMsForPm = detectMinReleaseAgeMsForPm2;
+    exports.detectMinReleaseAgeMs = detectMinReleaseAgeMs;
+    var node_child_process_1 = __require("node:child_process");
+    var config_parse_1 = require_config_parse();
+    var PROBE_TIMEOUT_MS2 = 3e3;
+    var OVERRIDE_ENV = "ARGENT_MIN_RELEASE_AGE_DAYS";
+    var PM_PROBES = {
+      // npm flattens `min-release-age` to an effective `before` cutoff, and some
+      // npm 11.x builds report `min-release-age=null` even while the policy is
+      // active. Probe `before`, which is what the resolver actually uses.
+      npm: { command: "npm config get before", parse: config_parse_1.parseBeforeAgeMs },
+      pnpm: {
+        command: "pnpm config get minimumReleaseAge",
+        parse: (stdout) => (0, config_parse_1.parseConfigValue)(stdout) * config_parse_1.MINUTE_MS
+      },
+      yarn: { command: "yarn config get npmMinimalAgeGate", parse: config_parse_1.parseYarnAgeGateMs }
+    };
+    function overrideMs() {
+      const override = process.env[OVERRIDE_ENV];
+      if (override === void 0)
+        return null;
+      const days = Number(override);
+      return Number.isFinite(days) && days > 0 ? days * config_parse_1.DAY_MS : 0;
+    }
+    function probe(p2) {
+      return new Promise((resolve3) => {
+        (0, node_child_process_1.exec)(p2.command, { timeout: PROBE_TIMEOUT_MS2, windowsHide: true }, (err, stdout) => {
+          if (err) {
+            resolve3(0);
+            return;
+          }
+          resolve3(p2.parse(stdout));
+        });
+      });
+    }
+    async function detectMinReleaseAgeMsForPm2(pm) {
+      const override = overrideMs();
+      if (override !== null)
+        return override;
+      const p2 = PM_PROBES[pm];
+      return p2 ? probe(p2) : 0;
+    }
+    async function detectMinReleaseAgeMs() {
+      const override = overrideMs();
+      if (override !== null)
+        return override;
+      const ages = await Promise.all(Object.values(PM_PROBES).map(probe));
+      return ages.reduce((max, ms) => Math.max(max, ms), 0);
+    }
+  }
+});
+
+// ../update-core/dist/registry.js
+var require_registry = __commonJS({
+  "../update-core/dist/registry.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fetchRegistryInfo = fetchRegistryInfo2;
+    var node_https_1 = __importDefault(__require("node:https"));
+    var REQUEST_TIMEOUT_MS = 1e4;
+    function fetchRegistryInfo2(url) {
+      return new Promise((resolve3) => {
+        let resolved = false;
+        const safeResolve = (value) => {
+          if (!resolved) {
+            resolved = true;
+            resolve3(value);
+          }
+        };
+        const req = node_https_1.default.get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
+          if (res.statusCode !== 200) {
+            res.resume();
+            safeResolve(null);
+            return;
+          }
+          let body = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            body += chunk;
+          });
+          res.on("end", () => {
+            try {
+              const json = JSON.parse(body);
+              const latestVersion = json["dist-tags"]?.latest;
+              if (!latestVersion) {
+                safeResolve(null);
+                return;
+              }
+              const times = json.time ?? {};
+              safeResolve({
+                latest: { version: latestVersion, publishedAt: times[latestVersion] ?? null },
+                times
+              });
+            } catch {
+              safeResolve(null);
+            }
+          });
+          res.on("error", () => safeResolve(null));
+        });
+        req.on("error", () => safeResolve(null));
+        req.on("timeout", () => {
+          req.destroy();
+          safeResolve(null);
+        });
+      });
+    }
+  }
+});
+
+// ../update-core/dist/pick-target.js
+var require_pick_target = __commonJS({
+  "../update-core/dist/pick-target.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pickInstallableTarget = pickInstallableTarget2;
+    var semver_1 = __importDefault(require_semver2());
+    function isStableUpgrade(version, current) {
+      if (!semver_1.default.valid(version) || semver_1.default.prerelease(version))
+        return false;
+      if (current === null)
+        return true;
+      if (!semver_1.default.valid(current))
+        return false;
+      return semver_1.default.gt(version, current);
+    }
+    function isOldEnough(publishedAt, minReleaseAgeMs) {
+      if (minReleaseAgeMs <= 0)
+        return true;
+      if (!publishedAt)
+        return false;
+      const published = Date.parse(publishedAt);
+      if (Number.isNaN(published))
+        return false;
+      return Date.now() - published >= minReleaseAgeMs;
+    }
+    function pickInstallableTarget2(latest, times, current, minReleaseAgeMs) {
+      if (minReleaseAgeMs <= 0) {
+        return isStableUpgrade(latest.version, current) ? latest : null;
+      }
+      let best = null;
+      for (const [version, publishedAt] of Object.entries(times)) {
+        if (!semver_1.default.valid(version) || semver_1.default.prerelease(version))
+          continue;
+        if (current !== null && !semver_1.default.gt(version, current))
+          continue;
+        if (!isOldEnough(publishedAt, minReleaseAgeMs))
+          continue;
+        if (best === null || semver_1.default.gt(version, best.version)) {
+          best = { version, publishedAt };
+        }
+      }
+      return best;
+    }
+  }
+});
+
+// ../update-core/dist/index.js
+var require_dist2 = __commonJS({
+  "../update-core/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pickInstallableTarget = exports.fetchRegistryInfo = exports.detectMinReleaseAgeMsForPm = exports.detectMinReleaseAgeMs = exports.parseYarnAgeGateMs = exports.parseBeforeAgeMs = exports.parseConfigValue = exports.DAY_MS = exports.MINUTE_MS = exports.SECOND_MS = void 0;
+    var config_parse_1 = require_config_parse();
+    Object.defineProperty(exports, "SECOND_MS", { enumerable: true, get: function() {
+      return config_parse_1.SECOND_MS;
+    } });
+    Object.defineProperty(exports, "MINUTE_MS", { enumerable: true, get: function() {
+      return config_parse_1.MINUTE_MS;
+    } });
+    Object.defineProperty(exports, "DAY_MS", { enumerable: true, get: function() {
+      return config_parse_1.DAY_MS;
+    } });
+    Object.defineProperty(exports, "parseConfigValue", { enumerable: true, get: function() {
+      return config_parse_1.parseConfigValue;
+    } });
+    Object.defineProperty(exports, "parseBeforeAgeMs", { enumerable: true, get: function() {
+      return config_parse_1.parseBeforeAgeMs;
+    } });
+    Object.defineProperty(exports, "parseYarnAgeGateMs", { enumerable: true, get: function() {
+      return config_parse_1.parseYarnAgeGateMs;
+    } });
+    var min_release_age_1 = require_min_release_age();
+    Object.defineProperty(exports, "detectMinReleaseAgeMs", { enumerable: true, get: function() {
+      return min_release_age_1.detectMinReleaseAgeMs;
+    } });
+    Object.defineProperty(exports, "detectMinReleaseAgeMsForPm", { enumerable: true, get: function() {
+      return min_release_age_1.detectMinReleaseAgeMsForPm;
+    } });
+    var registry_1 = require_registry();
+    Object.defineProperty(exports, "fetchRegistryInfo", { enumerable: true, get: function() {
+      return registry_1.fetchRegistryInfo;
+    } });
+    var pick_target_1 = require_pick_target();
+    Object.defineProperty(exports, "pickInstallableTarget", { enumerable: true, get: function() {
+      return pick_target_1.pickInstallableTarget;
+    } });
+  }
+});
+
 // ../../node_modules/@clack/core/dist/index.mjs
 import { styleText as v } from "node:util";
 import { stdout as x, stdin as D } from "node:process";
@@ -14326,8 +14611,24 @@ function runNpxSkills(args, interactive, cwd) {
 
 // ../argent-installer/src/update.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_semver2 = __toESM(require_semver2(), 1);
 import { execFileSync as execFileSync3 } from "node:child_process";
 
+// ../argent-installer/src/update-target.ts
+var import_update_core = __toESM(require_dist2(), 1);
+async function resolveInstallableUpdateTarget(pm, current) {
+  const info = await (0, import_update_core.fetchRegistryInfo)(`${NPM_REGISTRY}/${PACKAGE_NAME}`);
+  if (info === null) return null;
+  const minReleaseAgeMs = await (0, import_update_core.detectMinReleaseAgeMsForPm)(pm);
+  const target = (0, import_update_core.pickInstallableTarget)(info.latest, info.times, current, minReleaseAgeMs);
+  return {
+    latestVersion: info.latest.version,
+    latestPublishedAt: info.latest.publishedAt,
+    targetVersion: target?.version ?? null,
+    minReleaseAgeMs
+  };
+}
+
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
 import * as fs3 from "node:fs";
@@ -14364,8 +14665,21 @@ async function killToolServer() {
 }
 
 // ../argent-installer/src/update.ts
+function getRequestedVersion(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--version") {
+      return args[i + 1] ?? null;
+    }
+    if (arg?.startsWith("--version=")) {
+      return arg.slice("--version=".length) || null;
+    }
+  }
+  return null;
+}
 async function update(args) {
   const nonInteractive = args.includes("--yes") || args.includes("-y");
+  const requestedVersion = getRequestedVersion(args);
   ge(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" argent update ")));
   const globallyInstalled = isGloballyInstalled();
   const installed = globallyInstalled ? getGloballyInstalledVersion() : null;
@@ -14375,13 +14689,34 @@ async function update(args) {
   }
   const spinner = ft();
   spinner.start("Checking for updates...");
-  let latest;
-  try {
-    latest = getLatestVersion();
-  } catch (err) {
-    spinner.stop(import_picocolors3.default.red("Could not reach registry."));
-    R2.error(`Failed to check registry: ${err}`);
-    process.exit(1);
+  const pm = detectPackageManager();
+  let latest = null;
+  let target = null;
+  let minReleaseAgeMs = 0;
+  if (requestedVersion !== null) {
+    if (!import_semver2.default.valid(requestedVersion) || import_semver2.default.prerelease(requestedVersion)) {
+      spinner.stop(import_picocolors3.default.red("Invalid update target."));
+      R2.error(`Requested version is not a stable semver: ${requestedVersion}`);
+      process.exit(1);
+    }
+    target = requestedVersion;
+  } else {
+    let resolved;
+    try {
+      resolved = await resolveInstallableUpdateTarget(pm, installed);
+    } catch (err) {
+      spinner.stop(import_picocolors3.default.red("Could not reach registry."));
+      R2.error(`Failed to check registry: ${err}`);
+      process.exit(1);
+    }
+    if (resolved === null) {
+      spinner.stop(import_picocolors3.default.red("Could not reach registry."));
+      R2.error("Failed to determine the latest Argent release from the registry.");
+      process.exit(1);
+    }
+    latest = resolved.latestVersion;
+    target = resolved.targetVersion;
+    minReleaseAgeMs = resolved.minReleaseAgeMs;
   }
   spinner.stop("Version check complete.");
   if (installed) {
@@ -14389,19 +14724,26 @@ async function update(args) {
   } else {
     R2.warn(`${PACKAGE_NAME} is not installed globally.`);
   }
-  R2.info(`Latest:    ${import_picocolors3.default.cyan(`v${latest}`)}`);
-  const needsInstall = !installed || isNewerVersion(latest, installed);
-  if (needsInstall) {
+  if (latest) {
+    R2.info(`Latest:    ${import_picocolors3.default.cyan(`v${latest}`)}`);
+  }
+  if (target) {
+    const label = latest && latest !== target ? "Target:    " : "Version:   ";
+    const suffix = latest && latest !== target ? import_picocolors3.default.dim(" (newest installable)") : "";
+    R2.info(`${label}${import_picocolors3.default.cyan(`v${target}`)}${suffix}`);
+  }
+  const needsInstall = target !== null && (!installed || isNewerVersion(target, installed));
+  const latestIsNewer = latest !== null && (!installed || isNewerVersion(latest, installed));
+  if (needsInstall && target !== null) {
     if (installed) {
-      R2.warn(`Update available: ${import_picocolors3.default.yellow(`v${installed}`)} -> ${import_picocolors3.default.green(`v${latest}`)}`);
+      R2.warn(`Update available: ${import_picocolors3.default.yellow(`v${installed}`)} -> ${import_picocolors3.default.green(`v${target}`)}`);
     }
-    const pm = detectPackageManager();
-    const cmd = globalInstallCommand(pm, `${PACKAGE_NAME}@${latest}`);
+    const cmd = globalInstallCommand(pm, `${PACKAGE_NAME}@${target}`);
     const cmdStr = formatShellCommand(cmd);
     if (!nonInteractive) {
       R2.message(import_picocolors3.default.dim("  Press y for yes, n for no, enter to confirm."));
       const proceed = await ue({
-        message: installed ? `Update to v${latest}?` : `Install ${PACKAGE_NAME}@${latest} globally?`,
+        message: installed ? `Update to v${target}?` : `Install ${PACKAGE_NAME}@${target} globally?`,
         initialValue: true
       });
       if (q(proceed) || !proceed) {
@@ -14421,7 +14763,16 @@ async function update(args) {
       process.exit(1);
     }
   } else {
-    R2.success("Already on the latest version.");
+    if (latest && target === null && latestIsNewer && minReleaseAgeMs > 0) {
+      R2.warn(
+        `Latest version ${import_picocolors3.default.cyan(`v${latest}`)} is still held by your minimum-release-age policy.`
+      );
+      R2.info("No installable update is available yet.");
+    } else if (latest && target && latest !== target) {
+      R2.success("Already on the latest installable version.");
+    } else {
+      R2.success("Already on the latest version.");
+    }
   }
   spinner.start("Refreshing workspace configuration...");
   const projectRoot = resolveProjectRoot(process.cwd());

package/dist/mcp-server.mjs

@@ -15602,6 +15602,7 @@ async function ensureToolsServer(paths) {
 }
 
 // ../argent-mcp/src/content.ts
+import { readFile as readFile2 } from "node:fs/promises";
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 async function fetchPngBytes(url) {
   try {
@@ -15615,9 +15616,12 @@ async function fetchPngBytes(url) {
     return null;
   }
 }
-async function toMcpContent(result, outputHint) {
+async function toMcpContent(result, outputHint, args) {
   if (outputHint === "image" && result && typeof result === "object" && "url" in result) {
     const r = result;
+    if (isRecord(args) && args.includeImageInContext === false) {
+      return [{ type: "text", text: `Saved: ${r.path}` }];
+    }
     const buf = await fetchPngBytes(r.url);
     if (buf) {
       return [
@@ -15638,6 +15642,26 @@ async function toMcpContent(result, outputHint) {
   }
   return [{ type: "text", text: JSON.stringify(result, null, 2) }];
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function isScreenshotDiffResult(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.summary === "string";
+}
+async function screenshotDiffToMcpContent(result) {
+  const blocks = [];
+  if (typeof result.contextDiffPath === "string") {
+    const buf = await readFile2(result.contextDiffPath);
+    blocks.push({
+      type: "image",
+      data: buf.toString("base64"),
+      mimeType: "image/png"
+    });
+  }
+  blocks.push({ type: "text", text: result.summary });
+  return blocks;
+}
 async function flowRunToMcpContent(result) {
   const blocks = [];
   if (result.executionPrerequisite) {
@@ -15662,7 +15686,7 @@ async function flowRunToMcpContent(result) {
       });
     } else {
       blocks.push({ type: "text", text: `[${num}] ${step.tool}` });
-      const stepContent = await toMcpContent(step.result, step.outputHint);
+      const stepContent = await toMcpContent(step.result, step.outputHint, step.args);
       blocks.push(...stepContent);
     }
   }
@@ -15873,14 +15897,21 @@ async function startMcpServer(options) {
         isError: false,
         result
       });
-      let content = params.name === "flow-execute" && result && typeof result === "object" && "flow" in result && "steps" in result ? await flowRunToMcpContent(result) : await toMcpContent(result, outputHint);
+      let content;
+      if (params.name === "flow-execute" && result && typeof result === "object" && "flow" in result && "steps" in result) {
+        content = await flowRunToMcpContent(result);
+      } else if (params.name === "screenshot-diff" && isScreenshotDiffResult(result)) {
+        content = await screenshotDiffToMcpContent(result);
+      } else {
+        content = await toMcpContent(result, outputHint, params.arguments);
+      }
       const udid = getUdidFromArgs(params.arguments);
       if (autoScreenshotEnabled() && 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");
+          const screenshotContent = await toMcpContent(screenshotResult.result, "image", { udid });
           const hasImage = screenshotContent.some((b) => b.type === "image");
           if (hasImage) {
             content = [