@swmansion/argent 0.26.1-next.8 → 0.27.0

package/dist/client.js

@@ -0,0 +1,2417 @@
+import { createRequire as __createRequire } from 'node:module'; import { fileURLToPath as __fileURLToPath } from 'node:url'; import { dirname as __pathDirname } from 'node:path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __pathDirname(__filename);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs6 = __require("fs");
+    var path10 = __require("path");
+    var os2 = __require("os");
+    var crypto2 = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs6.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path10.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs6.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path10.join(os2.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path10.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path11 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs6.readFileSync(path11, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path11} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative2 = path10.relative(process.cwd(), filePath);
+            shortPaths.push(relative2);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// ../configuration-core/src/flags.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var FLAG_REGISTRY = [
+  {
+    name: "disable-auto-screenshot",
+    description: "Disable the automatic screenshot captured after interaction tools."
+  },
+  {
+    name: "disable-auto-describe",
+    description: "Disable the accessibility element tree appended after interaction tools."
+  },
+  {
+    name: "argent-lens",
+    description: "Argent Lens \u2014 the propose_variant / await_user_selection tools and the Electron preview window for staging UI design variants and letting a human pick among them. Off by default while the feature is in development."
+  },
+  {
+    name: "artifacts-list-endpoint",
+    description: "Expose GET /artifacts for remote artifact inventory consumers."
+  },
+  {
+    name: "tool-server-event-log",
+    description: "Write structured tool-server lifecycle events to a JSONL file."
+  },
+  {
+    name: "boot-sound",
+    description: "Default boot-device's `sound` argument to true so Android emulators boot with audio output instead of muted. Only the argument's default changes \u2014 an explicit `sound: false` on a call still boots muted."
+  },
+  {
+    name: "microinteractions",
+    description: "Amplify device actions with matching animations of the host window, so what happens on the guest is also visible on the desktop. Purely cosmetic, macOS only, and never affects whether the underlying action succeeds. Off by default."
+  },
+  {
+    name: "video-watermark",
+    description: "Overlay the argent corner watermark on recorded screen videos. On by default; turn it off with `argent disable video-watermark`.",
+    defaultEnabled: true
+  }
+];
+function getFlagDefinition(name, registry = FLAG_REGISTRY) {
+  return registry.find((def) => def.name === name);
+}
+var PROJECT_MARKERS = [".argent", ".git", "package.json"];
+function findProjectRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs.existsSync(path.join(current, marker))) return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveProjectRoot(startDir) {
+  return findProjectRoot(startDir) ?? path.resolve(startDir);
+}
+function getFlagsPath(scope, options = {}) {
+  const home = options.homeDir ?? homedir();
+  if (scope === "global") {
+    return path.join(home, ".argent", "flags.json");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path.join(resolveProjectRoot(cwd), ".argent", "flags.json");
+}
+function readFlagsFile(filePath) {
+  let raw;
+  try {
+    raw = fs.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 options.default ?? false;
+}
+function isFeatureEnabled(name, options = {}, registry = FLAG_REGISTRY) {
+  return isFlagEnabled(name, {
+    ...options,
+    default: getFlagDefinition(name, registry)?.defaultEnabled ?? false
+  });
+}
+
+// ../configuration-core/src/paths.ts
+import * as os from "node:os";
+import * as path2 from "node:path";
+function nonEmpty(value) {
+  if (value == void 0) return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : value;
+}
+function resolveHomeDir(options = {}) {
+  if (options.homeDir) return options.homeDir;
+  return process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
+}
+function argentHomeDir() {
+  return path2.join(resolveHomeDir(), ".argent");
+}
+function configDir(scope = "global", options = {}) {
+  if (scope === "global") {
+    return path2.join(resolveHomeDir(options), ".argent");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path2.join(resolveProjectRoot(cwd), ".argent");
+}
+function configFilePath(scope = "global", options = {}) {
+  return path2.join(configDir(scope, options), "config.json");
+}
+
+// ../configuration-core/src/config.ts
+import * as crypto from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+function readConfigObject(scope = "global", options = {}) {
+  try {
+    const raw = fs2.readFileSync(configFilePath(scope, options), "utf8");
+    const json = JSON.parse(raw);
+    if (json && typeof json === "object" && !Array.isArray(json)) {
+      return json;
+    }
+  } catch {
+  }
+  return {};
+}
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function splitKey(dottedKey) {
+  const parts = dottedKey.split(".");
+  if (parts.length === 0 || parts.some((p) => p === "")) {
+    throw new Error(`Invalid config key "${dottedKey}": empty path segment`);
+  }
+  for (const p of parts) {
+    if (FORBIDDEN_SEGMENTS.has(p)) {
+      throw new Error(`Invalid config key "${dottedKey}": forbidden segment "${p}"`);
+    }
+  }
+  return parts;
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getAtPath(obj, dottedKey) {
+  const parts = splitKey(dottedKey);
+  let cur = obj;
+  for (const part of parts) {
+    if (!isPlainObject(cur)) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+
+// ../configuration-core/src/secrets.ts
+var import_dotenv = __toESM(require_main(), 1);
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+
+// ../configuration-core/src/merge.ts
+function mergeRestrictive(local, global) {
+  if (local === void 0) return global;
+  if (global === void 0) return local;
+  if (typeof local === "boolean" && typeof global === "boolean") {
+    return local && global;
+  }
+  if (typeof local === "number" && typeof global === "number") {
+    return Math.min(local, global);
+  }
+  return local;
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+function mergeUnion(local, global) {
+  const l = toArray(local);
+  const g = toArray(global);
+  if (l === null && g === null) return local ?? global;
+  const merged = [...g ?? [], ...l ?? []];
+  return Array.from(new Set(merged));
+}
+function mergeIntersection(local, global) {
+  const l = toArray(local);
+  const g = toArray(global);
+  if (l === null && g === null) return local ?? global;
+  if (l === null) return global;
+  if (g === null) return local;
+  const globalSet = new Set(g);
+  return l.filter((item) => globalSet.has(item));
+}
+function applyMergePolicy(policy, local, global) {
+  if (typeof policy === "function") return policy({ local, global });
+  switch (policy) {
+    case "prioritize-local":
+      return local ?? global;
+    case "prioritize-global":
+      return global ?? local;
+    case "prioritize-restrictive":
+      return mergeRestrictive(local, global);
+    case "union":
+      return mergeUnion(local, global);
+    case "intersection":
+      return mergeIntersection(local, global);
+    default: {
+      const _exhaustive = policy;
+      return _exhaustive;
+    }
+  }
+}
+
+// ../configuration-core/src/config-schema.ts
+import { isAbsolute } from "node:path";
+function asBoolean(raw) {
+  return typeof raw === "boolean" ? raw : void 0;
+}
+function asString(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function asPositiveInteger(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? raw : void 0;
+}
+var MIN_SCRIPT_HEAP_LIMIT_MB = 32;
+var MIN_SCRIPT_TIMEOUT_MS = 100;
+function asStringArray(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const item of raw) {
+    if (typeof item === "string" && item.trim() !== "") out.push(item.trim());
+  }
+  return out;
+}
+var CONFIG_SCHEMA = [
+  {
+    key: "telemetry.enabled",
+    description: "Whether anonymous opt-out telemetry is enabled (on by default; environment opt-outs like DO_NOT_TRACK are not reflected here \u2014 `argent telemetry status` shows effective consent). `false` in either scope wins, so a committed project opt-out holds for every teammate.",
+    scopes: ["project", "global"],
+    parse: asBoolean,
+    merge: "prioritize-restrictive",
+    // Opt-out: consent.ts reads an unstored value as enabled, so the config
+    // surface must show the same rather than "(unset)".
+    default: true,
+    // Opt-in/out goes through the dedicated command so the live client is
+    // drained/reset, not just the file rewritten.
+    manageCommand: "argent telemetry"
+  },
+  {
+    key: "allowlist.enabled",
+    description: "Whether `argent update` re-applies editor auto-approve allowlist rules. Unset (the default) keeps the current behavior: update refreshes the rules for editors that already have argent configured. Set to `false` to keep update from touching editor allowlists. `false` in either scope wins, so a committed project opt-out holds for every teammate.",
+    scopes: ["project", "global"],
+    parse: asBoolean,
+    merge: "prioritize-restrictive",
+    example: "false"
+  },
+  {
+    key: "lens.agent",
+    description: "Coding-agent id remembered by `argent lens` to skip the picker.",
+    scopes: ["project", "global"],
+    parse: asString,
+    merge: "prioritize-local",
+    example: "claude"
+  },
+  {
+    key: "ios.additionalDeviceSets",
+    description: "Additional CoreSimulator device-set directories whose simulators argent should see alongside the default set. Absolute paths (or ~/\u2026); relative entries resolve against the project root (project scope) or home (global scope).",
+    scopes: ["project", "global"],
+    parse: asStringArray,
+    // Additive rather than shadowing: global baseline first, project extras
+    // after, deduplicated. `getAdditionalIosDeviceSets` re-implements this union
+    // (path resolution must precede dedup) and guards on the preset staying "union".
+    merge: "union",
+    example: '["~/DeviceSets/ci"]'
+  },
+  {
+    key: "android.sdkRoot",
+    description: "Android SDK root argent uses instead of `ANDROID_HOME`, for hosts whose SDK is not where the environment says (Nix, custom layouts). Absolute or `~/`-prefixed. Applies to the tool-server and to the simulator-server it starts. `adb` on PATH still wins, as it does with the environment variable.",
+    scopes: ["project", "global"],
+    parse: (raw) => {
+      const value = asString(raw);
+      return value !== void 0 && (value === "~" || value.startsWith("~/") || isAbsolute(value)) ? value : void 0;
+    },
+    expected: "an absolute path, or one starting with `~/`",
+    merge: "prioritize-local",
+    example: "~/Library/Android/sdk"
+  },
+  {
+    key: "recordings.directory",
+    description: "Directory where finished screen recordings (mp4) are saved on the client host. Absolute, `~`-prefixed, or relative to the project root (home dir when not in a project). Unset \u21D2 `.argent/recordings` under the project root.",
+    scopes: ["project", "global"],
+    parse: asString,
+    // Resolved on the client (the machine the mp4 is persisted to), so with a
+    // remote `argent link` tool-server it is the *client's* config that decides.
+    merge: "prioritize-local",
+    example: "~/Movies/argent"
+  },
+  // Global-scope only: a checked-in `.argent/config.json` must not raise the
+  // ceiling on how much of the machine a script step may occupy. `merge` is
+  // nominal here — the project scope of a global-only key is never read.
+  {
+    key: "scripts.maxTimeoutMs",
+    description: `Upper bound, in milliseconds, on the time limit a flow \`script\` step may ask for (default 300000 \u2014 five minutes). Bounds how long one script can occupy the host. Values below ${MIN_SCRIPT_TIMEOUT_MS} ms are refused: the step starts a Node process before the script runs, so a smaller ceiling ends a script that did nothing wrong.`,
+    scopes: ["global"],
+    parse: (raw) => {
+      const value = asPositiveInteger(raw);
+      return value !== void 0 && value >= MIN_SCRIPT_TIMEOUT_MS ? value : void 0;
+    },
+    expected: `a whole number of milliseconds, at least ${MIN_SCRIPT_TIMEOUT_MS}`,
+    merge: "prioritize-global",
+    default: 5 * 6e4,
+    example: "300000"
+  },
+  {
+    key: "scripts.heapLimitMb",
+    description: `Old-space heap limit, in MiB, given to each flow \`script\` process (default 512). Values below ${MIN_SCRIPT_HEAP_LIMIT_MB} MiB are refused: that is already below what importing a real npm dependency needs, and under about 5 MiB the process dies inside V8's own startup before any script runs.`,
+    scopes: ["global"],
+    parse: (raw) => {
+      const value = asPositiveInteger(raw);
+      return value !== void 0 && value >= MIN_SCRIPT_HEAP_LIMIT_MB ? value : void 0;
+    },
+    expected: `a whole number of MiB, at least ${MIN_SCRIPT_HEAP_LIMIT_MB}`,
+    merge: "prioritize-global",
+    default: 512,
+    example: "512"
+  }
+];
+function getConfigDefinition(key, registry = CONFIG_SCHEMA) {
+  return registry.find((def) => def.key === key);
+}
+
+// ../configuration-core/src/config-access.ts
+import * as path5 from "node:path";
+function readScopeValue(def, scope, options) {
+  if (!def.scopes.includes(scope)) return void 0;
+  const raw = getAtPath(readConfigObject(scope, options), def.key);
+  return raw === void 0 ? void 0 : def.parse(raw);
+}
+function getConfigValue(def, options = {}) {
+  const local = readScopeValue(def, "project", options);
+  const global = readScopeValue(def, "global", options);
+  const merged = applyMergePolicy(def.merge, local, global);
+  return merged ?? def.default;
+}
+function getConfigValueByKey(key, options = {}, registry = CONFIG_SCHEMA) {
+  const def = requireDefinition(key, registry);
+  return getConfigValue(def, options);
+}
+function requireDefinition(key, registry = CONFIG_SCHEMA) {
+  const def = getConfigDefinition(key, registry);
+  if (!def) {
+    throw new UnknownConfigKeyError(key);
+  }
+  return def;
+}
+var UnknownConfigKeyError = class extends Error {
+  constructor(key) {
+    super(`Unknown configuration key "${key}".`);
+    this.key = key;
+    this.name = "UnknownConfigKeyError";
+  }
+  key;
+};
+
+// ../argent-tools-client/src/launcher.ts
+import * as net from "node:net";
+import * as fs4 from "node:fs";
+import * as path6 from "node:path";
+import * as readline from "node:readline";
+import { homedir as homedir3 } from "node:os";
+import { spawn, execFileSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, writeFile, readFile, readdir, unlink, rename, chmod } from "node:fs/promises";
+var STATE_DIR = path6.join(homedir3(), ".argent");
+var STATE_FILE = path6.join(STATE_DIR, "tool-server.json");
+var LOG_FILE = path6.join(STATE_DIR, "tool-server.log");
+var LOCK_FILE = path6.join(STATE_DIR, "tool-server.lock");
+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,
+    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;
+  if (paths.installKind) env.ARGENT_INSTALL_KIND = paths.installKind;
+  if (paths.installProjectRoot) env.ARGENT_PROJECT_ROOT = paths.installProjectRoot;
+  return env;
+}
+function generateToken() {
+  return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
+}
+function findFreePort() {
+  return new Promise((resolve7, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (!addr || typeof addr !== "object") {
+        srv.close(() => reject(new Error("Could not bind to find free port")));
+        return;
+      }
+      const port = addr.port;
+      srv.close((err) => {
+        if (err) reject(err);
+        else resolve7(port);
+      });
+    });
+    srv.on("error", reject);
+  });
+}
+function isVersionNewer(a, b) {
+  const parse = (v) => {
+    const [core = "", ...preParts] = v.split("+")[0].split("-");
+    const nums = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (nums.length === 0 || nums.some((n) => Number.isNaN(n))) return null;
+    return { nums, pre: preParts.length > 0 ? preParts.join("-").split(".") : [] };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return false;
+  for (let i = 0; i < 3; i++) {
+    const x = pa.nums[i] ?? 0;
+    const y = pb.nums[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  if (pa.pre.length === 0 && pb.pre.length === 0) return false;
+  if (pa.pre.length === 0) return true;
+  if (pb.pre.length === 0) return false;
+  for (let i = 0; i < Math.max(pa.pre.length, pb.pre.length); i++) {
+    const x = pa.pre[i];
+    const y = pb.pre[i];
+    if (x === void 0) return false;
+    if (y === void 0) return true;
+    if (x === y) continue;
+    const xn = /^\d+$/.test(x) ? Number.parseInt(x, 10) : null;
+    const yn = /^\d+$/.test(y) ? Number.parseInt(y, 10) : null;
+    if (xn !== null && yn !== null) return xn > yn;
+    if (xn !== null) return false;
+    if (yn !== null) return true;
+    return x > y;
+  }
+  return false;
+}
+function readBundlePackageVersion(bundlePath) {
+  try {
+    const pkg = JSON.parse(
+      fs4.readFileSync(path6.join(path6.dirname(bundlePath), "..", "package.json"), "utf8")
+    );
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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(), timeoutMs);
+  try {
+    const res = await fetch(`${formatUrl(healthCheckHost(host), port)}/tools`, {
+      signal: controller.signal,
+      headers: authHeaders(token)
+    });
+    await res.body?.cancel().catch(() => {
+    });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var SPAWN_READY_TIMEOUT_MS = 15e3;
+function killSpawnedChild(child, pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }
+}
+function spawnToolsServer(paths, port, options = {}) {
+  return new Promise((resolve7, reject) => {
+    let logFd;
+    try {
+      fs4.mkdirSync(STATE_DIR, { recursive: true });
+      logFd = fs4.openSync(LOG_FILE, "a");
+    } catch {
+      logFd = fs4.openSync("/dev/null", "w");
+    }
+    const { bun, deno, electron } = process.versions;
+    const nodeBin = !(bun || deno || electron) && fs4.existsSync(process.execPath) ? process.execPath : "node";
+    const child = spawn(nodeBin, [paths.bundlePath, "start"], {
+      detached: true,
+      stdio: ["ignore", "pipe", logFd],
+      env: buildToolsServerEnv(paths, port, process.env, options)
+    });
+    child.unref();
+    const pid = child.pid;
+    if (!pid) {
+      child.once(
+        "error",
+        (err) => reject(
+          new Error(
+            err.code === "ENOENT" && nodeBin === "node" ? "Could not start the argent tool-server: `node` was not found on PATH. Install Node.js 20+ or add it to PATH." : `Could not start the argent tool-server: ${err.message}`
+          )
+        )
+      );
+      return;
+    }
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      fn();
+    };
+    const rejectAndKill = (err) => settle(() => {
+      killSpawnedChild(child, pid);
+      reject(err);
+    });
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
+      if (match) {
+        const actualPort = parseInt(match[1], 10);
+        rl.close();
+        child.stdout?.resume();
+        child.stdout?.unref?.();
+        settle(() => resolve7({ port: actualPort, pid }));
+      }
+    });
+    child.on("error", (err) => {
+      rl.close();
+      rejectAndKill(err);
+    });
+    child.on("exit", (code) => {
+      rl.close();
+      settle(() => reject(new Error(`tool-server exited with code ${code} before becoming ready`)));
+    });
+    const timer = setTimeout(() => {
+      rl.close();
+      rejectAndKill(new Error("Timed out waiting for tools server to become ready"));
+    }, options.readyTimeoutMs ?? SPAWN_READY_TIMEOUT_MS);
+    rl.on("close", () => clearTimeout(timer));
+  });
+}
+function stateFileForBundle(bundlePath) {
+  const key = createHash("sha256").update(bundlePath).digest("hex").slice(0, 12);
+  return path6.join(STATE_DIR, `tool-server-${key}.json`);
+}
+async function readStateFile(file) {
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readToolsServerState(bundlePath) {
+  if (bundlePath === void 0) return readStateFile(STATE_FILE);
+  const own = await readStateFile(stateFileForBundle(bundlePath));
+  if (own) return own;
+  const legacy = await readStateFile(STATE_FILE);
+  return legacy && legacy.bundlePath === bundlePath ? legacy : null;
+}
+async function writeToolsServerState(state) {
+  const target = stateFileForBundle(state.bundlePath);
+  await mkdir(STATE_DIR, { recursive: true });
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(tmp, 384);
+    await rename(tmp, target);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
+}
+async function clearToolsServerState(bundlePath) {
+  const files = [STATE_FILE];
+  if (bundlePath !== void 0) {
+    files[0] = stateFileForBundle(bundlePath);
+    const legacy = await readStateFile(STATE_FILE);
+    if (legacy && legacy.bundlePath === bundlePath) files.push(STATE_FILE);
+  }
+  for (const file of files) {
+    try {
+      await unlink(file);
+    } catch {
+    }
+  }
+}
+var STATE_FILE_RE = /^tool-server(-[0-9a-f]{12})?\.json$/;
+async function readAllToolsServerStates() {
+  let names;
+  try {
+    names = await readdir(STATE_DIR);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!STATE_FILE_RE.test(name)) continue;
+    const file = path6.join(STATE_DIR, name);
+    const state = await readStateFile(file);
+    if (state) out.push({ file, state });
+  }
+  return out;
+}
+async function sweepDeadStateFiles() {
+  for (const { file } of await readAllToolsServerStates()) {
+    if (file === STATE_FILE) continue;
+    const fresh = await readStateFile(file);
+    if (!fresh) continue;
+    if (!isProcessAlive(fresh.pid)) {
+      await unlink(file).catch(() => {
+      });
+      continue;
+    }
+    if (fs4.existsSync(fresh.bundlePath)) continue;
+    if (!couldBeOurToolServer(fresh.pid, fresh.bundlePath)) continue;
+    await unlink(file).catch(() => {
+    });
+    void terminatePid(fresh.pid, () => couldBeOurToolServer(fresh.pid, fresh.bundlePath));
+  }
+}
+var readState = readToolsServerState;
+var writeState = writeToolsServerState;
+var SIGTERM_GRACE_MS = 6e3;
+var SIGKILL_GRACE_MS = 1e3;
+var KILL_POLL_MS = 100;
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, KILL_POLL_MS));
+  }
+  return !isProcessAlive(pid);
+}
+async function terminatePid(pid, stillOurs) {
+  if (!isProcessAlive(pid)) return;
+  if (stillOurs && !stillOurs()) return;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  if (await waitForExit(pid, SIGTERM_GRACE_MS)) return;
+  if (stillOurs && !(isProcessAlive(pid) && stillOurs())) return;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return;
+  }
+  await waitForExit(pid, SIGKILL_GRACE_MS);
+}
+async function killToolServer(bundlePath) {
+  const state = await readState(bundlePath);
+  if (!state) return false;
+  const stillOurs = () => couldBeOurToolServer(state.pid, state.bundlePath);
+  const alive = isProcessAlive(state.pid);
+  if (alive && !stillOurs()) return false;
+  if (alive) await terminatePid(state.pid, stillOurs);
+  await clearToolsServerState(bundlePath ?? state.bundlePath);
+  return alive;
+}
+var PS_BIN = ["/bin/ps", "/usr/bin/ps"].find((p) => fs4.existsSync(p)) ?? "ps";
+var PS_WIDTH_FLAGS = ["-ww"];
+var PS_LOCALE = process.platform === "darwin" ? "en_US.UTF-8" : "C.UTF-8";
+function readProcessCommandLine(pid, flags = PS_WIDTH_FLAGS, env = { ...process.env, LC_ALL: PS_LOCALE }) {
+  return execFileSync(PS_BIN, [...flags, "-p", String(pid), "-o", "command="], {
+    env,
+    encoding: "utf8",
+    timeout: 2e3,
+    // A recycled pid can sit on a process with an argv past Node's 1 MiB exec
+    // default, where the overrun surfaces as ENOBUFS instead of a command line.
+    // Same ceiling as tool-server's vega-process ps probes.
+    maxBuffer: 16 * 1024 * 1024,
+    // Piping ps's stderr is what puts a rejected flag ("ps: invalid option --
+    // 'w'") into the thrown error's message.
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function couldBeOurToolServer(pid, marker) {
+  if (!marker) return false;
+  if (process.platform === "win32") return true;
+  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const ours = new RegExp(`(?:^|[\\t\\n\\v\\f\\r ])${escaped} start(?:[\\t\\n\\v\\f\\r ]|$)`);
+  const nonAscii = [...marker].some((c) => c.charCodeAt(0) > 127);
+  let failure;
+  for (const env of [void 0, process.env]) {
+    try {
+      if (ours.test(readProcessCommandLine(pid, PS_WIDTH_FLAGS, env))) return true;
+      failure = void 0;
+      if (!nonAscii) break;
+    } catch (err) {
+      failure = String(err);
+      if (err.code === "ETIMEDOUT") break;
+    }
+  }
+  if (failure !== void 0) {
+    process.stderr.write(
+      `[launcher] ps could not read pid ${pid}'s command line; leaving it alone: ${failure}
+`
+    );
+  }
+  return false;
+}
+var LOCK_WAIT_TIMEOUT_MS = 3e4;
+var LOCK_STALE_MS = 45e3;
+var LOCK_POLL_MS = 100;
+function spawnLockIsStale() {
+  try {
+    const { pid, ts } = JSON.parse(fs4.readFileSync(LOCK_FILE, "utf8"));
+    if (typeof pid === "number" && pid > 0 && !isProcessAlive(pid)) return true;
+    if (typeof ts === "number" && Date.now() - ts > LOCK_STALE_MS) return true;
+    return false;
+  } catch {
+    try {
+      return Date.now() - fs4.statSync(LOCK_FILE).mtimeMs > LOCK_STALE_MS;
+    } catch {
+      return true;
+    }
+  }
+}
+async function acquireSpawnLock() {
+  try {
+    fs4.mkdirSync(STATE_DIR, { recursive: true });
+  } catch {
+    return null;
+  }
+  const nonce = randomBytes(8).toString("hex");
+  const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      const fd = fs4.openSync(LOCK_FILE, "wx");
+      try {
+        fs4.writeSync(fd, JSON.stringify({ pid: process.pid, nonce, ts: Date.now() }));
+      } finally {
+        fs4.closeSync(fd);
+      }
+      let released = false;
+      return {
+        release: () => {
+          if (released) return;
+          released = true;
+          try {
+            const cur = JSON.parse(fs4.readFileSync(LOCK_FILE, "utf8"));
+            if (cur.pid === process.pid && cur.nonce === nonce) fs4.unlinkSync(LOCK_FILE);
+          } catch {
+          }
+        }
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+      if (spawnLockIsStale()) {
+        try {
+          fs4.unlinkSync(LOCK_FILE);
+        } catch {
+        }
+        if (!fs4.existsSync(LOCK_FILE)) continue;
+      }
+      if (Date.now() >= deadline) return null;
+      await new Promise((r) => setTimeout(r, LOCK_POLL_MS));
+    }
+  }
+}
+async function reusableHandle(state, wantBundlePath, wantVersion) {
+  if (!state || !isProcessAlive(state.pid)) return null;
+  if (wantBundlePath !== void 0 && state.bundlePath !== wantBundlePath) return null;
+  if (wantBundlePath !== void 0 && state.version !== void 0) {
+    const diskVersion = readBundlePackageVersion(wantBundlePath);
+    if (diskVersion !== void 0) {
+      if (diskVersion !== state.version) return null;
+    } else if (wantVersion !== void 0 && state.version !== wantVersion && isVersionNewer(wantVersion, state.version)) {
+      return null;
+    }
+  }
+  const host = state.host ?? "127.0.0.1";
+  const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
+  if (!healthy) return null;
+  return { url: formatUrl(healthCheckHost(host), state.port), token: state.token ?? "" };
+}
+async function ensureToolsServer(paths) {
+  const fast = await reusableHandle(
+    await readState(paths.bundlePath),
+    paths.bundlePath,
+    paths.version
+  );
+  if (fast) return fast;
+  const lock = await acquireSpawnLock();
+  try {
+    const state = await readState(paths.bundlePath);
+    const reuse = await reusableHandle(state, paths.bundlePath, paths.version);
+    if (reuse) return reuse;
+    if (state && state.managed === "autospawn" && state.bundlePath === paths.bundlePath && isProcessAlive(state.pid) && couldBeOurToolServer(state.pid, state.bundlePath)) {
+      await terminatePid(state.pid, () => couldBeOurToolServer(state.pid, state.bundlePath));
+    }
+    await clearToolsServerState(paths.bundlePath);
+    await sweepDeadStateFiles();
+    if (!fs4.existsSync(paths.bundlePath)) {
+      throw new Error(
+        `The argent install serving this session is gone from disk (${paths.bundlePath}) \u2014 it was likely updated or removed. Restart the editor's MCP connection to reconnect.`
+      );
+    }
+    const diskVersion = readBundlePackageVersion(paths.bundlePath) ?? paths.version;
+    const token = generateToken();
+    const port = await findFreePort();
+    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,
+      version: diskVersion,
+      host: "127.0.0.1",
+      token,
+      managed: "autospawn"
+    });
+    return { url: formatUrl("127.0.0.1", actualPort), token };
+  } finally {
+    lock?.release();
+  }
+}
+
+// ../argent-tools-client/src/link-config.ts
+import * as path7 from "node:path";
+import { homedir as homedir4 } 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 = path7.join(homedir4(), ".argent");
+var LINK_FILE = path7.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" };
+}
+
+// ../argent-tools-client/src/file-inputs.ts
+import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path8 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 dirname3, join as join7, posix, resolve as resolve5, 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", dirname3(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 = resolve5(destDir);
+  const resolved = resolve5(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 join7(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 join7(destDir, real[0]);
+}
+async function safeExtractTarGz(tarPath, destDir, expectedName) {
+  await assertSafeArchive(tarPath, destDir);
+  await execFileAsync("tar", ["-xzf", tarPath, "-C", destDir]);
+  return resolveMember(destDir, expectedName);
+}
+
+// ../registry/src/artifacts.ts
+import { stat } from "node:fs/promises";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { basename as basename2, extname } from "node:path";
+
+// ../registry/src/file-inputs.ts
+var FLOW_NAME_CHARSET = "[A-Za-z0-9_-]+";
+var FLOW_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}$`);
+var FLOW_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.yaml$`);
+var SCRIPT_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.mjs$`);
+
+// ../registry/src/failure-codes.ts
+var FAILURE_CODES = {
+  ARGENT_UNCLASSIFIED_FAILURE: "ARGENT_UNCLASSIFIED_FAILURE",
+  REGISTRY_SERVICE_NOT_FOUND: "REGISTRY_SERVICE_NOT_FOUND",
+  REGISTRY_SERVICE_INITIALIZATION_FAILED: "REGISTRY_SERVICE_INITIALIZATION_FAILED",
+  REGISTRY_TOOL_NOT_FOUND: "REGISTRY_TOOL_NOT_FOUND",
+  REGISTRY_TOOL_EXECUTION_FAILED: "REGISTRY_TOOL_EXECUTION_FAILED",
+  REGISTRY_TOOL_FAILURE_UNCLASSIFIED: "REGISTRY_TOOL_FAILURE_UNCLASSIFIED",
+  REGISTRY_SERVICE_TERMINATING: "REGISTRY_SERVICE_TERMINATING",
+  HTTP_TOOL_NOT_FOUND: "HTTP_TOOL_NOT_FOUND",
+  HTTP_ZOD_VALIDATION_FAILED: "HTTP_ZOD_VALIDATION_FAILED",
+  HTTP_CAPABILITY_UNSUPPORTED_OPERATION: "HTTP_CAPABILITY_UNSUPPORTED_OPERATION",
+  HTTP_DEVICE_RESOLUTION_FAILED: "HTTP_DEVICE_RESOLUTION_FAILED",
+  HTTP_DEPENDENCY_PREFLIGHT_MISSING: "HTTP_DEPENDENCY_PREFLIGHT_MISSING",
+  CLI_RUN_TOOL_NOT_FOUND: "CLI_RUN_TOOL_NOT_FOUND",
+  CLI_RUN_FLAG_PARSE_FAILED: "CLI_RUN_FLAG_PARSE_FAILED",
+  CLI_RUN_ARGS_NOT_OBJECT: "CLI_RUN_ARGS_NOT_OBJECT",
+  CLI_RUN_ARGS_JSON_INVALID: "CLI_RUN_ARGS_JSON_INVALID",
+  CLI_RUN_INPUT_VALIDATION_FAILED: "CLI_RUN_INPUT_VALIDATION_FAILED",
+  CLI_RUN_TOOL_CALL_FAILED: "CLI_RUN_TOOL_CALL_FAILED",
+  CLI_RUN_SAVE_IMAGE_FAILED: "CLI_RUN_SAVE_IMAGE_FAILED",
+  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",
+  INSTALL_LOCAL_PACKAGE_FAILED: "INSTALL_LOCAL_PACKAGE_FAILED",
+  INSTALL_LOCAL_PRECONDITION_FAILED: "INSTALL_LOCAL_PRECONDITION_FAILED",
+  INSTALL_MODE_FLAG_CONFLICT: "INSTALL_MODE_FLAG_CONFLICT",
+  INSTALL_FROM_TAR_PACKAGE_FAILED: "INSTALL_FROM_TAR_PACKAGE_FAILED",
+  INSTALL_INIT_TRIGGERED_UPDATE_FAILED: "INSTALL_INIT_TRIGGERED_UPDATE_FAILED",
+  INSTALL_SKILLS_REFRESH_FAILED: "INSTALL_SKILLS_REFRESH_FAILED",
+  INSTALL_UNCLASSIFIED_FAILED: "INSTALL_UNCLASSIFIED_FAILED",
+  UPDATE_INSTALLED_VERSION_DETECT_FAILED: "UPDATE_INSTALLED_VERSION_DETECT_FAILED",
+  UPDATE_INVALID_TARGET_VERSION: "UPDATE_INVALID_TARGET_VERSION",
+  UPDATE_REGISTRY_CHECK_FAILED: "UPDATE_REGISTRY_CHECK_FAILED",
+  UPDATE_TOOLSERVER_STOP_FAILED: "UPDATE_TOOLSERVER_STOP_FAILED",
+  UPDATE_PACKAGE_ACTION_FAILED: "UPDATE_PACKAGE_ACTION_FAILED",
+  UPDATE_UNCLASSIFIED_FAILED: "UPDATE_UNCLASSIFIED_FAILED",
+  UNINSTALL_TOOLSERVER_STOP_FAILED: "UNINSTALL_TOOLSERVER_STOP_FAILED",
+  UNINSTALL_PACKAGE_ACTION_FAILED: "UNINSTALL_PACKAGE_ACTION_FAILED",
+  UNINSTALL_UNCLASSIFIED_FAILED: "UNINSTALL_UNCLASSIFIED_FAILED",
+  VEGA_CLI_COMMAND_FAILED: "VEGA_CLI_COMMAND_FAILED",
+  VEGA_INPUT_UNAVAILABLE: "VEGA_INPUT_UNAVAILABLE",
+  VEGA_DEVICE_NOT_FOUND: "VEGA_DEVICE_NOT_FOUND",
+  VEGA_DEVICE_NOT_REGISTERED: "VEGA_DEVICE_NOT_REGISTERED",
+  VEGA_MULTIPLE_DEVICES: "VEGA_MULTIPLE_DEVICES",
+  VEGA_BOOT_TIMEOUT: "VEGA_BOOT_TIMEOUT",
+  VEGA_IMAGE_NOT_FOUND: "VEGA_IMAGE_NOT_FOUND",
+  VEGA_ALREADY_RUNNING: "VEGA_ALREADY_RUNNING",
+  VEGA_SCREENSHOT_FAILED: "VEGA_SCREENSHOT_FAILED",
+  VEGA_TEXT_INVALID: "VEGA_TEXT_INVALID",
+  ANDROID_ADB_NOT_FOUND: "ANDROID_ADB_NOT_FOUND",
+  ANDROID_EMULATOR_NOT_FOUND: "ANDROID_EMULATOR_NOT_FOUND",
+  ANDROID_ADB_COMMAND_FAILED: "ANDROID_ADB_COMMAND_FAILED",
+  ANDROID_ADB_BOOT_TERMINAL_STATE: "ANDROID_ADB_BOOT_TERMINAL_STATE",
+  ANDROID_ADB_BOOT_TIMEOUT: "ANDROID_ADB_BOOT_TIMEOUT",
+  SIMULATOR_NETWORK_TIMEOUT: "SIMULATOR_NETWORK_TIMEOUT",
+  SIMULATOR_NETWORK_CONNECTION_REFUSED: "SIMULATOR_NETWORK_CONNECTION_REFUSED",
+  SIMULATOR_NETWORK_CONNECTION_RESET: "SIMULATOR_NETWORK_CONNECTION_RESET",
+  SIMULATOR_NETWORK_ERROR: "SIMULATOR_NETWORK_ERROR",
+  SIMULATOR_NON_JSON_RESPONSE: "SIMULATOR_NON_JSON_RESPONSE",
+  SIMULATOR_HTTP_ERROR_RESPONSE: "SIMULATOR_HTTP_ERROR_RESPONSE",
+  SIMULATOR_MISSING_RESPONSE_FIELDS: "SIMULATOR_MISSING_RESPONSE_FIELDS",
+  SIMULATOR_SCREENSHOT_FAILED: "SIMULATOR_SCREENSHOT_FAILED",
+  SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING: "SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING",
+  SIMULATOR_SERVER_DEVICE_ID_INVALID: "SIMULATOR_SERVER_DEVICE_ID_INVALID",
+  SIMULATOR_SERVER_READY_EXITED: "SIMULATOR_SERVER_READY_EXITED",
+  SIMULATOR_SERVER_READY_TIMEOUT: "SIMULATOR_SERVER_READY_TIMEOUT",
+  SIMULATOR_SERVER_PROCESS_ERROR: "SIMULATOR_SERVER_PROCESS_ERROR",
+  SIMULATOR_SERVER_TERMINATED: "SIMULATOR_SERVER_TERMINATED",
+  SIMULATOR_COMMAND_REJECTED: "SIMULATOR_COMMAND_REJECTED",
+  SIMULATOR_COMMAND_ACK_TIMEOUT: "SIMULATOR_COMMAND_ACK_TIMEOUT",
+  SIMULATOR_COMMAND_TRANSPORT_FAILED: "SIMULATOR_COMMAND_TRANSPORT_FAILED",
+  // Physical iOS devices: the XCUITest-runner blueprint lifecycle, the runner
+  // command client, and the `xcrun devicectl` subprocess wrapper (simulators
+  // use the SIMULATOR_* set).
+  IOS_DEVICE_RUNNER_FACTORY_OPTIONS_MISSING: "IOS_DEVICE_RUNNER_FACTORY_OPTIONS_MISSING",
+  IOS_DEVICE_RUNNER_NOT_READY: "IOS_DEVICE_RUNNER_NOT_READY",
+  IOS_DEVICE_RUNNER_TERMINATED: "IOS_DEVICE_RUNNER_TERMINATED",
+  IOS_DEVICE_RUNNER_EXITED: "IOS_DEVICE_RUNNER_EXITED",
+  // The runner answered a command with an ok:false envelope.
+  IOS_DEVICE_RUNNER_COMMAND_FAILED: "IOS_DEVICE_RUNNER_COMMAND_FAILED",
+  // The usbmux or HTTP exchange with a reachable runner failed.
+  IOS_DEVICE_RUNNER_TRANSPORT_FAILED: "IOS_DEVICE_RUNNER_TRANSPORT_FAILED",
+  IOS_DEVICECTL_COMMAND_FAILED: "IOS_DEVICECTL_COMMAND_FAILED",
+  AX_QUERY_TIMEOUT: "AX_QUERY_TIMEOUT",
+  AX_DAEMON_READY_TIMEOUT: "AX_DAEMON_READY_TIMEOUT",
+  AX_DAEMON_EXITED_BEFORE_READY: "AX_DAEMON_EXITED_BEFORE_READY",
+  AX_DAEMON_PROCESS_ERROR: "AX_DAEMON_PROCESS_ERROR",
+  AX_FACTORY_OPTIONS_MISSING: "AX_FACTORY_OPTIONS_MISSING",
+  AX_WRONG_PLATFORM: "AX_WRONG_PLATFORM",
+  AX_DEVICE_ID_INVALID: "AX_DEVICE_ID_INVALID",
+  AX_DESCRIBE_ERROR: "AX_DESCRIBE_ERROR",
+  AX_QUERY_FAILED: "AX_QUERY_FAILED",
+  ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED: "ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED",
+  ANDROID_LAUNCH_AM_START_FAILED: "ANDROID_LAUNCH_AM_START_FAILED",
+  ANDROID_OPEN_URL_FAILED: "ANDROID_OPEN_URL_FAILED",
+  ANDROID_REINSTALL_INSTALL_FAILED: "ANDROID_REINSTALL_INSTALL_FAILED",
+  ANDROID_RESTART_FAILED: "ANDROID_RESTART_FAILED",
+  ANDROID_SETTINGS_PERMISSION_FAILED: "ANDROID_SETTINGS_PERMISSION_FAILED",
+  IOS_LAUNCH_SIMCTL_FAILED: "IOS_LAUNCH_SIMCTL_FAILED",
+  IOS_OPEN_URL_FAILED: "IOS_OPEN_URL_FAILED",
+  IOS_REINSTALL_INSTALL_FAILED: "IOS_REINSTALL_INSTALL_FAILED",
+  IOS_RESTART_LAUNCH_FAILED: "IOS_RESTART_LAUNCH_FAILED",
+  IOS_SETTINGS_PERMISSION_FAILED: "IOS_SETTINGS_PERMISSION_FAILED",
+  IOS_SHAKE_FAILED: "IOS_SHAKE_FAILED",
+  ANDROID_SHAKE_FAILED: "ANDROID_SHAKE_FAILED",
+  // The hinge of a foldable iOS simulator: the server refused the request on a
+  // foldable (a bad angle, a hinge that would not move) vs. nothing to fold —
+  // a device that is not foldable, no hinge route, a remote simulator.
+  IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
+  IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
+  PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
+  SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
+  NATIVE_DEVTOOLS_DESCRIBE_ERROR: "NATIVE_DEVTOOLS_DESCRIBE_ERROR",
+  NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR",
+  NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR",
+  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",
+  NATIVE_DEVTOOLS_SERVICE_DISPOSED: "NATIVE_DEVTOOLS_SERVICE_DISPOSED",
+  NATIVE_DEVTOOLS_SOCKET_BIND_FAILED: "NATIVE_DEVTOOLS_SOCKET_BIND_FAILED",
+  NATIVE_DEVTOOLS_SOCKET_NOT_PUBLISHED: "NATIVE_DEVTOOLS_SOCKET_NOT_PUBLISHED",
+  NATIVE_DEVTOOLS_ATTACH_FAILED: "NATIVE_DEVTOOLS_ATTACH_FAILED",
+  NATIVE_DEVTOOLS_ATTACH_LOST: "NATIVE_DEVTOOLS_ATTACH_LOST",
+  NATIVE_TARGET_NO_CONNECTED_APPS: "NATIVE_TARGET_NO_CONNECTED_APPS",
+  NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND: "NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND",
+  NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS: "NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS",
+  ANDROID_DEVTOOLS_ADB_NOT_FOUND: "ANDROID_DEVTOOLS_ADB_NOT_FOUND",
+  ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED: "ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED",
+  ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY: "ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY",
+  ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR: "ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR",
+  ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT: "ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT",
+  ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING: "ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING",
+  ANDROID_DEVTOOLS_WRONG_PLATFORM: "ANDROID_DEVTOOLS_WRONG_PLATFORM",
+  ANDROID_DEVTOOLS_DEVICE_ID_INVALID: "ANDROID_DEVTOOLS_DEVICE_ID_INVALID",
+  ANDROID_DEVTOOLS_HELPER_TERMINATED: "ANDROID_DEVTOOLS_HELPER_TERMINATED",
+  ANDROID_DEVTOOLS_HELPER_INSTALL_FAILED: "ANDROID_DEVTOOLS_HELPER_INSTALL_FAILED",
+  ANDROID_DEVTOOLS_HELPER_REPAIR_FAILED: "ANDROID_DEVTOOLS_HELPER_REPAIR_FAILED",
+  ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED: "ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED",
+  ANDROID_DEVTOOLS_RPC_ERROR: "ANDROID_DEVTOOLS_RPC_ERROR",
+  ANDROID_DEVTOOLS_RPC_TIMEOUT: "ANDROID_DEVTOOLS_RPC_TIMEOUT",
+  ANDROID_DEVTOOLS_SOCKET_CLOSED: "ANDROID_DEVTOOLS_SOCKET_CLOSED",
+  ANDROID_SCREEN_SIZE_PARSE_FAILED: "ANDROID_SCREEN_SIZE_PARSE_FAILED",
+  ANDROID_SCREEN_SIZE_NON_POSITIVE: "ANDROID_SCREEN_SIZE_NON_POSITIVE",
+  ANDROID_UIAUTOMATOR_PARSE_FAILED: "ANDROID_UIAUTOMATOR_PARSE_FAILED",
+  ANDROID_UIAUTOMATOR_CAPTURE_FAILED: "ANDROID_UIAUTOMATOR_CAPTURE_FAILED",
+  DEBUGGER_METRO_NOT_RUNNING: "DEBUGGER_METRO_NOT_RUNNING",
+  DEBUGGER_METRO_NO_TARGETS: "DEBUGGER_METRO_NO_TARGETS",
+  DEBUGGER_CDP_RUNTIME_EXCEPTION: "DEBUGGER_CDP_RUNTIME_EXCEPTION",
+  DEBUGGER_CDP_BINDING_TIMEOUT: "DEBUGGER_CDP_BINDING_TIMEOUT",
+  DEBUGGER_CDP_BINDING_UNAVAILABLE: "DEBUGGER_CDP_BINDING_UNAVAILABLE",
+  DEBUGGER_CDP_PROTOCOL_ERROR: "DEBUGGER_CDP_PROTOCOL_ERROR",
+  DEBUGGER_CDP_CONNECT_FAILED: "DEBUGGER_CDP_CONNECT_FAILED",
+  DEBUGGER_CDP_SOCKET_CLOSED_BEFORE_OPEN: "DEBUGGER_CDP_SOCKET_CLOSED_BEFORE_OPEN",
+  DEBUGGER_CDP_NOT_CONNECTED: "DEBUGGER_CDP_NOT_CONNECTED",
+  DEBUGGER_CDP_REQUEST_TIMEOUT: "DEBUGGER_CDP_REQUEST_TIMEOUT",
+  DEBUGGER_CDP_CONNECTION_CLOSED: "DEBUGGER_CDP_CONNECTION_CLOSED",
+  DEBUGGER_TARGET_DEVICE_MISMATCH: "DEBUGGER_TARGET_DEVICE_MISMATCH",
+  DEBUGGER_EVALUATE_EXPRESSION_THREW: "DEBUGGER_EVALUATE_EXPRESSION_THREW",
+  DEBUGGER_RELOAD_FAILED: "DEBUGGER_RELOAD_FAILED",
+  JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED: "JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED",
+  JS_RUNTIME_PAYLOAD_INVALID: "JS_RUNTIME_PAYLOAD_INVALID",
+  JS_RUNTIME_PAYLOAD_DEVICE_MISSING: "JS_RUNTIME_PAYLOAD_DEVICE_MISSING",
+  JS_RUNTIME_PAYLOAD_PORT_INVALID: "JS_RUNTIME_PAYLOAD_PORT_INVALID",
+  JS_RUNTIME_CDP_DISCONNECTED: "JS_RUNTIME_CDP_DISCONNECTED",
+  JS_RUNTIME_PAUSED: "JS_RUNTIME_PAUSED",
+  NETWORK_INSPECTOR_CDP_DISCONNECTED: "NETWORK_INSPECTOR_CDP_DISCONNECTED",
+  REACT_PROFILER_NO_ACTIVE_SESSION: "REACT_PROFILER_NO_ACTIVE_SESSION",
+  REACT_PROFILER_CDP_CONNECTION_LOST: "REACT_PROFILER_CDP_CONNECTION_LOST",
+  REACT_PROFILER_NO_CPU_PROFILE: "REACT_PROFILER_NO_CPU_PROFILE",
+  REACT_PROFILER_RUNTIME_EXCEPTION: "REACT_PROFILER_RUNTIME_EXCEPTION",
+  REACT_PROFILER_NO_RUNTIME_DATA: "REACT_PROFILER_NO_RUNTIME_DATA",
+  REACT_PROFILER_SESSION_PAYLOAD_INVALID: "REACT_PROFILER_SESSION_PAYLOAD_INVALID",
+  REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING: "REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING",
+  REACT_PROFILER_SESSION_CDP_DISCONNECTED: "REACT_PROFILER_SESSION_CDP_DISCONNECTED",
+  REACT_PROFILER_CDP_NOT_CONNECTED: "REACT_PROFILER_CDP_NOT_CONNECTED",
+  REACT_PROFILER_STATE_READ_FAILED: "REACT_PROFILER_STATE_READ_FAILED",
+  REACT_PROFILER_DEVTOOLS_HOOK_MISSING: "REACT_PROFILER_DEVTOOLS_HOOK_MISSING",
+  REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED",
+  REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED",
+  REACT_PROFILER_DEVTOOLS_RENDERER_MISSING: "REACT_PROFILER_DEVTOOLS_RENDERER_MISSING",
+  REACT_PROFILER_START_FAILED: "REACT_PROFILER_START_FAILED",
+  REACT_PROFILER_START_VERIFY_FAILED: "REACT_PROFILER_START_VERIFY_FAILED",
+  REACT_PROFILER_HOOK_ERROR: "REACT_PROFILER_HOOK_ERROR",
+  REACT_PROFILER_ANALYZE_NO_DATA: "REACT_PROFILER_ANALYZE_NO_DATA",
+  NATIVE_PROFILER_FACTORY_OPTIONS_MISSING: "NATIVE_PROFILER_FACTORY_OPTIONS_MISSING",
+  NATIVE_PROFILER_WRONG_PLATFORM: "NATIVE_PROFILER_WRONG_PLATFORM",
+  NATIVE_PROFILER_APP_PROCESS_LIST_FAILED: "NATIVE_PROFILER_APP_PROCESS_LIST_FAILED",
+  NATIVE_PROFILER_APP_LIST_FAILED: "NATIVE_PROFILER_APP_LIST_FAILED",
+  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",
+  NATIVE_PROFILER_XCTRACE_READY_EXITED: "NATIVE_PROFILER_XCTRACE_READY_EXITED",
+  NATIVE_PROFILER_XCTRACE_PROCESS_ERROR: "NATIVE_PROFILER_XCTRACE_PROCESS_ERROR",
+  NATIVE_PROFILER_XCTRACE_READY_TIMEOUT: "NATIVE_PROFILER_XCTRACE_READY_TIMEOUT",
+  NATIVE_PROFILER_TRACE_TEMPLATE_MISSING: "NATIVE_PROFILER_TRACE_TEMPLATE_MISSING",
+  NATIVE_PROFILER_NO_ACTIVE_SESSION: "NATIVE_PROFILER_NO_ACTIVE_SESSION",
+  NATIVE_PROFILER_SESSION_TORN_DOWN: "NATIVE_PROFILER_SESSION_TORN_DOWN",
+  NATIVE_PROFILER_APP_PROCESS_NOT_FOUND: "NATIVE_PROFILER_APP_PROCESS_NOT_FOUND",
+  NATIVE_PROFILER_NO_EXPORTED_TRACE: "NATIVE_PROFILER_NO_EXPORTED_TRACE",
+  // Android perfetto start failures, mirroring the iOS xctrace set above.
+  NATIVE_PROFILER_PERFETTO_PROCESS_ERROR: "NATIVE_PROFILER_PERFETTO_PROCESS_ERROR",
+  NATIVE_PROFILER_PERFETTO_READY_TIMEOUT: "NATIVE_PROFILER_PERFETTO_READY_TIMEOUT",
+  NATIVE_PROFILER_PERFETTO_READY_EXITED: "NATIVE_PROFILER_PERFETTO_READY_EXITED",
+  // iOS and Android share one capture path (simulator-server frames into
+  // ffmpeg), so these name the failing stage, not the device family.
+  SCREEN_RECORDING_FACTORY_OPTIONS_MISSING: "SCREEN_RECORDING_FACTORY_OPTIONS_MISSING",
+  SCREEN_RECORDING_WRONG_PLATFORM: "SCREEN_RECORDING_WRONG_PLATFORM",
+  SCREEN_RECORDING_ALREADY_ACTIVE: "SCREEN_RECORDING_ALREADY_ACTIVE",
+  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",
+  SCREEN_RECORDING_STREAM_UNAVAILABLE: "SCREEN_RECORDING_STREAM_UNAVAILABLE",
+  SCREEN_RECORDING_FFMPEG_NOT_FOUND: "SCREEN_RECORDING_FFMPEG_NOT_FOUND",
+  FLOW_PROJECT_ROOT_INVALID: "FLOW_PROJECT_ROOT_INVALID",
+  FLOW_NAME_INVALID: "FLOW_NAME_INVALID",
+  FLOW_NO_ACTIVE_RECORDING: "FLOW_NO_ACTIVE_RECORDING",
+  FLOW_FILE_INVALID: "FLOW_FILE_INVALID",
+  FLOW_FILE_WRITE_FAILED: "FLOW_FILE_WRITE_FAILED",
+  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",
+  PROFILER_NATIVE_TRACE_MISSING: "PROFILER_NATIVE_TRACE_MISSING",
+  PROFILER_NATIVE_METADATA_MISSING: "PROFILER_NATIVE_METADATA_MISSING",
+  PROFILER_NATIVE_METADATA_INVALID: "PROFILER_NATIVE_METADATA_INVALID",
+  CHROMIUM_CDP_UNREACHABLE: "CHROMIUM_CDP_UNREACHABLE",
+  CHROMIUM_CDP_NO_PAGE_TARGET: "CHROMIUM_CDP_NO_PAGE_TARGET",
+  CHROMIUM_CDP_INVALID_RESPONSE: "CHROMIUM_CDP_INVALID_RESPONSE",
+  CHROMIUM_DEVICE_ID_INVALID: "CHROMIUM_DEVICE_ID_INVALID",
+  CHROMIUM_PARAM_INVALID: "CHROMIUM_PARAM_INVALID",
+  CHROMIUM_INPUT_INVALID: "CHROMIUM_INPUT_INVALID",
+  CHROMIUM_WINDOW_HIDDEN: "CHROMIUM_WINDOW_HIDDEN",
+  CHROMIUM_VIEWPORT_READ_FAILED: "CHROMIUM_VIEWPORT_READ_FAILED",
+  CHROMIUM_SCREENSHOT_FAILED: "CHROMIUM_SCREENSHOT_FAILED",
+  CHROMIUM_STORAGE_EVAL_FAILED: "CHROMIUM_STORAGE_EVAL_FAILED",
+  CHROMIUM_TAB_NOT_FOUND: "CHROMIUM_TAB_NOT_FOUND",
+  CHROMIUM_TAB_OPEN_FAILED: "CHROMIUM_TAB_OPEN_FAILED",
+  CHROMIUM_DESCRIBE_FAILED: "CHROMIUM_DESCRIBE_FAILED",
+  CHROMIUM_ELECTRON_APP_PATH_INVALID: "CHROMIUM_ELECTRON_APP_PATH_INVALID",
+  CHROMIUM_ELECTRON_SPAWN_FAILED: "CHROMIUM_ELECTRON_SPAWN_FAILED",
+  CHROMIUM_ELECTRON_CDP_TIMEOUT: "CHROMIUM_ELECTRON_CDP_TIMEOUT",
+  CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
+  KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
+  KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+  KEYBOARD_TEXT_AND_KEY_COMBINED: "KEYBOARD_TEXT_AND_KEY_COMBINED",
+  KEYBOARD_INPUT_NOT_FOCUSED: "KEYBOARD_INPUT_NOT_FOCUSED",
+  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
+  SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
+  BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
+  BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",
+  BOOT_ANDROID_NO_AVDS: "BOOT_ANDROID_NO_AVDS",
+  BOOT_ANDROID_AVD_NOT_FOUND: "BOOT_ANDROID_AVD_NOT_FOUND",
+  BOOT_ANDROID_ADB_UNAVAILABLE: "BOOT_ANDROID_ADB_UNAVAILABLE",
+  BOOT_ANDROID_GPU_MODE_INVALID: "BOOT_ANDROID_GPU_MODE_INVALID",
+  BOOT_ANDROID_ADB_REGISTER_TIMEOUT: "BOOT_ANDROID_ADB_REGISTER_TIMEOUT",
+  BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE: "BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE",
+  BOOT_ANDROID_FIRST_FRAME_TIMEOUT: "BOOT_ANDROID_FIRST_FRAME_TIMEOUT",
+  BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE: "BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE",
+  BOOT_ANDROID_COLD_BOOT_FAILED: "BOOT_ANDROID_COLD_BOOT_FAILED",
+  /**
+   * External device providers
+   * @see [external-devices.ts](../../tool-server/src/utils/external-devices.ts)
+   */
+  EXTERNAL_DEVICE_CAPABILITY_DENIED: "EXTERNAL_DEVICE_CAPABILITY_DENIED",
+  EXTERNAL_DEVICE_ENDPOINT_FORBIDDEN: "EXTERNAL_DEVICE_ENDPOINT_FORBIDDEN",
+  EXTERNAL_DEVICE_LIFECYCLE_REFUSED: "EXTERNAL_DEVICE_LIFECYCLE_REFUSED",
+  EXTERNAL_DEVICE_REVOCATION_INCOMPLETE: "EXTERNAL_DEVICE_REVOCATION_INCOMPLETE",
+  EXTERNAL_DEVICE_UNAVAILABLE: "EXTERNAL_DEVICE_UNAVAILABLE"
+};
+
+// ../registry/src/errors.ts
+var FAILURE_SIGNAL_NAMES = [
+  "SIGABRT",
+  "SIGHUP",
+  "SIGINT",
+  "SIGKILL",
+  "SIGQUIT",
+  "SIGTERM"
+];
+var FAILURE_SPAWN_CODES = ["EACCES", "ENOENT", "EPERM", "ETIMEDOUT"];
+var FALLBACK_SIGNAL = {
+  error_code: FAILURE_CODES.ARGENT_UNCLASSIFIED_FAILURE,
+  failure_stage: "unclassified",
+  failure_area: "registry",
+  error_kind: "unknown"
+};
+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 randomUUID3 } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+var resolvedDuringInvocation = new AsyncLocalStorage();
+
+// ../argent-tools-client/src/file-inputs.ts
+var FILE_INPUT_MARKER2 = "__argentFileInput";
+var CLIENT_FILE_MARKER2 = "__argentClientFile";
+var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
+function interpolatePath(template, args) {
+  let missing = false;
+  const out = template.replace(/\$\{([A-Za-z0-9_]+)\}/g, (_m, name) => {
+    const v = args[name];
+    if (typeof v !== "string" || v.length === 0) {
+      missing = true;
+      return "";
+    }
+    return v;
+  });
+  return missing ? null : out;
+}
+async function tarball(sourcePath) {
+  const tarPath = path8.join(tmpdir(), `argent-upload-${randomUUID4()}.tar.gz`);
+  await createTarGzFile(sourcePath, tarPath);
+  return tarPath;
+}
+function sha256File(filePath) {
+  return new Promise((resolve7, reject) => {
+    const hash = createHash2("sha256");
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve7(hash.digest("hex"))).on("error", reject);
+  });
+}
+async function uploadTar(tarPath, endpoint, signal) {
+  const init = {
+    method: "POST",
+    headers: {
+      "content-type": "application/gzip",
+      ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
+    },
+    body: createReadStream(tarPath),
+    duplex: "half",
+    signal
+  };
+  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;
+  }
+  const record = args;
+  let out = null;
+  for (const spec of specs) {
+    if (spec.skipWhenSet && record[spec.skipWhenSet] !== void 0) continue;
+    if (spec.target in record && typeof record[spec.target] !== "string") continue;
+    const filePath = interpolatePath(spec.path, record);
+    if (filePath === null) continue;
+    if (spec.target in record && record[spec.target] !== filePath) continue;
+    const wire = { [FILE_INPUT_MARKER2]: true, path: filePath };
+    if (spec.kind === "file") {
+      try {
+        const st = await stat2(filePath);
+        if (st.isFile()) {
+          wire.size = st.size;
+          wire.mtimeMs = st.mtimeMs;
+          if (opts.includeContent && st.size <= MAX_CONTENT_BYTES) {
+            wire.content = (await readFile3(filePath)).toString("base64");
+          } else if (opts.includeContent) {
+            wire.contentOmitted = "size-limit";
+          }
+        }
+      } catch {
+      }
+    }
+    if (spec.kind === "tar-upload") {
+      const st = await stat2(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 ${path8.basename(filePath)} to the remote tool-server...
+`
+          );
+          tarPath = await tarball(filePath);
+          wire.contentHash = await sha256File(tarPath);
+          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint, opts.signal);
+        } finally {
+          if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    }
+    out = out ?? { ...record };
+    out[spec.target] = wire;
+  }
+  return out ?? args;
+}
+function isAllowedClientFilePath(p) {
+  if (!path8.isAbsolute(p)) return false;
+  const segments = p.split(/[\\/]+/);
+  if (segments.includes("..")) return false;
+  const file = segments[segments.length - 1] ?? "";
+  if (!FLOW_FILE_NAME_PATTERN.test(file)) return false;
+  return segments[segments.length - 3] === ".argent" && segments[segments.length - 2] === "flows";
+}
+function isClientFileDirective2(value) {
+  return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER2] === true && typeof value.path === "string" && typeof value.content === "string";
+}
+async function applyClientFileDirectives(result) {
+  const written = [];
+  async function walk(value) {
+    if (isClientFileDirective2(value)) {
+      if (!isAllowedClientFilePath(value.path)) return null;
+      try {
+        await mkdir3(path8.dirname(value.path), { recursive: true });
+        await writeFile3(value.path, value.content, "utf8");
+        written.push(value.path);
+        return value.path;
+      } 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, written };
+}
+
+// ../argent-tools-client/src/tools-client.ts
+var ToolInvocationError = class extends Error {
+  errorCode;
+  errorKind;
+  issues;
+  constructor(message, signal) {
+    super(message);
+    this.name = "ToolInvocationError";
+    this.errorCode = signal?.errorCode;
+    this.errorKind = signal?.errorKind;
+    this.issues = signal?.issues;
+  }
+};
+function authHeaders2(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function consumeToolStream(body, onProgress, signal) {
+  let final;
+  const handleLine = (line) => {
+    if (!line.trim()) return;
+    const msg = JSON.parse(line);
+    if (msg.event === "progress") onProgress(msg.data);
+    else if (msg.event === "result") final = { data: msg.data, note: msg.note };
+    else if (msg.event === "error") {
+      throw new ToolInvocationError(msg.error ?? "tool invocation failed", {
+        errorCode: msg.error_code,
+        errorKind: msg.error_kind
+      });
+    }
+  };
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffered.indexOf("\n")) !== -1) {
+        signal?.throwIfAborted();
+        const line = buffered.slice(0, newline);
+        buffered = buffered.slice(newline + 1);
+        handleLine(line);
+      }
+    }
+    buffered += decoder.decode();
+    if (buffered.trim()) handleLine(buffered);
+  } catch (err) {
+    void reader.cancel().catch(() => {
+    });
+    throw err;
+  }
+  signal?.throwIfAborted();
+  if (!final) {
+    throw new Error("tool stream ended without a result \u2014 connection lost mid-run?");
+  }
+  const { result: data } = await applyClientFileDirectives(final.data);
+  return { data, note: final.note };
+}
+function errorBodyMessage(body) {
+  if (Array.isArray(body.issues) && typeof body.message === "string") return body.message;
+  return body.error ?? body.message;
+}
+function createToolsClient(options = {}) {
+  let cached = null;
+  async function baseUrl() {
+    const resolved = await getResolvedToolsUrl();
+    if (resolved.url) {
+      return { url: resolved.url, token: resolved.token ?? "" };
+    }
+    if (cached) return cached;
+    if (!options.paths) {
+      throw new Error(
+        "tools-client: cannot spawn tool-server without `paths`; set ARGENT_TOOLS_URL or pass paths to createToolsClient()"
+      );
+    }
+    cached = await ensureToolsServer(options.paths);
+    return cached;
+  }
+  async function fetchTools(opts) {
+    opts?.signal?.throwIfAborted();
+    const { url, token } = await baseUrl();
+    const res = await fetch(`${url}/tools`, {
+      headers: authHeaders2(token),
+      signal: opts?.signal
+    });
+    if (!res.ok) throw new Error(`GET /tools failed: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    return json.tools;
+  }
+  async function fetchTool(name, opts) {
+    const tools = await fetchTools(opts);
+    return tools.find((t) => t.name === name) ?? null;
+  }
+  async function callTool(name, args, opts) {
+    opts?.signal?.throwIfAborted();
+    const { url, token } = await baseUrl();
+    let finalArgs = args;
+    const meta = await fetchTool(name, { signal: opts?.signal });
+    if (meta?.fileInputs?.length) {
+      const { url: routedUrl } = await getResolvedToolsUrl();
+      const isRemote = routedUrl !== null;
+      finalArgs = await prepareFileInputs(meta.fileInputs, args ?? {}, {
+        includeContent: isRemote,
+        uploadEndpoint: isRemote ? { url, token } : void 0,
+        signal: opts?.signal
+      });
+    }
+    const res = await fetch(`${url}/tools/${encodeURIComponent(name)}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...opts?.onProgress ? { Accept: "application/x-ndjson" } : {},
+        ...authHeaders2(token)
+      },
+      body: JSON.stringify(finalArgs ?? {}),
+      signal: opts?.signal
+    });
+    const contentType = res.headers.get("content-type") ?? "";
+    if (opts?.onProgress && res.ok && res.body && contentType.includes("application/x-ndjson")) {
+      return consumeToolStream(res.body, opts.onProgress, opts.signal);
+    }
+    const json = await res.json().catch(() => {
+      opts?.signal?.throwIfAborted();
+      return {};
+    });
+    if (!res.ok) {
+      throw new ToolInvocationError(errorBodyMessage(json) ?? `${res.status} ${res.statusText}`, {
+        errorCode: json.error_code,
+        errorKind: json.error_kind,
+        issues: Array.isArray(json.issues) ? json.issues : void 0
+      });
+    }
+    opts?.signal?.throwIfAborted();
+    const { result: data } = await applyClientFileDirectives(json.data);
+    return { data, note: json.note };
+  }
+  return { fetchTools, fetchTool, callTool, baseUrl };
+}
+
+// ../argent-tools-client/src/artifacts.ts
+import { copyFile, mkdir as mkdir4, readFile as readFile4, realpath, rm as rm3, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename4, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute4, join as join9, normalize, resolve as resolve6, sep as sep2 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+var ARTIFACT_MARKER2 = "__argentArtifact";
+function isArtifactHandle(value) {
+  return !!value && typeof value === "object" && value[ARTIFACT_MARKER2] === 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 = createHash3("sha1").update(cwd).digest("hex").slice(0, 6);
+  const name = sanitizeSegment(basename4(cwd)) || "root";
+  return `${name}-${hash}`;
+}
+function artifactsRoot() {
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join9(tmpdir2(), "argent-artifacts");
+}
+function artifactDir(deviceId) {
+  const parts = [artifactsRoot(), projectSlug(), sessionId()];
+  if (deviceId) parts.push(sanitizeSegment(deviceId));
+  return join9(...parts);
+}
+function durableBaseDir() {
+  const projectRoot = findProjectRoot(process.cwd());
+  return projectRoot ?? dirname5(argentHomeDir());
+}
+var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize(".argent/recordings")]);
+var RECORDINGS_SAVE_DIR = normalize(".argent/recordings");
+function configuredRecordingsDir() {
+  let value;
+  try {
+    value = getConfigValueByKey("recordings.directory");
+  } catch {
+    return null;
+  }
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  const home = dirname5(argentHomeDir());
+  const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep2}`) ? join9(home, trimmed.slice(2)) : trimmed;
+  return resolve6(durableBaseDir(), expanded);
+}
+var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
+async function readCapped(res, cap) {
+  const headers = res.headers;
+  const declared = Number(headers?.get?.("content-length"));
+  if (Number.isFinite(declared) && declared > cap) return null;
+  const body = res.body;
+  if (!body?.getReader) {
+    const buf = Buffer.from(await res.arrayBuffer());
+    return buf.length > cap ? null : buf;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > cap) {
+      await reader.cancel().catch(() => {
+      });
+      return null;
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks);
+}
+async function writeDurableUnique(dir, filename, write) {
+  const ext = extname2(filename);
+  const stem = filename.slice(0, filename.length - ext.length);
+  for (let i = 1; i <= 1e3; i++) {
+    const candidate = i === 1 ? filename : `${stem} (${i})${ext}`;
+    const path10 = join9(dir, candidate);
+    try {
+      await write(path10);
+      return path10;
+    } catch (err) {
+      if (err?.code === "EEXIST") continue;
+      throw err;
+    }
+  }
+  return null;
+}
+function durableSaveTarget(handle) {
+  if (typeof handle.saveDir !== "string" || !handle.saveDir || handle.archive) return null;
+  const rel = normalize(handle.saveDir);
+  if (isAbsolute4(rel) || rel === ".." || rel.startsWith(`..${sep2}`) || rel.split(sep2).includes("..")) {
+    return null;
+  }
+  if (!ALLOWED_SAVE_DIRS.has(rel)) return null;
+  if (rel === RECORDINGS_SAVE_DIR) {
+    const configured = configuredRecordingsDir();
+    if (configured) {
+      return {
+        dir: configured,
+        path: join9(configured, sanitizeSegment(handle.filename)),
+        base: configured,
+        rel: ""
+      };
+    }
+  }
+  const base = durableBaseDir();
+  const dir = join9(base, rel);
+  return { dir, path: join9(dir, sanitizeSegment(handle.filename)), base, rel };
+}
+async function confineToRealBase(dir, base, rel) {
+  try {
+    const realDir = await realpath(dir);
+    const realBase = await realpath(base);
+    return realDir === join9(realBase, rel);
+  } catch {
+    return false;
+  }
+}
+async function resolveLocalFile(handle) {
+  if (!handle.hostPath) return null;
+  try {
+    const st = await stat3(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 tarball2 = join9(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  try {
+    await writeFile4(tarball2, data);
+    return await safeExtractTarGz(tarball2, dir, handle.filename);
+  } catch {
+    return null;
+  } finally {
+    await rm3(tarball2, { force: true }).catch(() => {
+    });
+  }
+}
+async function materializeArtifacts(result, ctx) {
+  const images = [];
+  const fetchFn = ctx.fetchImpl ?? fetch;
+  const authHeaders3 = ctx.authToken ? { Authorization: `Bearer ${ctx.authToken}` } : {};
+  const dir = artifactDir(ctx.deviceId);
+  let dirReady = false;
+  async function ensureDir() {
+    if (!dirReady) {
+      await mkdir4(dir, { recursive: true });
+      dirReady = true;
+    }
+  }
+  async function walk(value) {
+    if (isArtifactHandle(value)) {
+      const localPath = await resolveLocalFile(value);
+      const saveTarget = durableSaveTarget(value);
+      if (saveTarget) {
+        const filename = basename4(saveTarget.path);
+        try {
+          await mkdir4(saveTarget.dir, { recursive: true });
+          if (!await confineToRealBase(saveTarget.dir, saveTarget.base, saveTarget.rel)) {
+            return null;
+          }
+          if (localPath) {
+            const finalPath2 = await writeDurableUnique(
+              saveTarget.dir,
+              filename,
+              (p) => copyFile(localPath, p, fsConstants.COPYFILE_EXCL)
+            );
+            if (!finalPath2) return null;
+            if (value.mimeType.startsWith("image/")) {
+              images.push({
+                localPath: finalPath2,
+                data: await readFile4(finalPath2),
+                mimeType: value.mimeType
+              });
+            }
+            return finalPath2;
+          }
+          if (!Number.isInteger(value.size) || value.size <= 0 || value.size > MAX_DURABLE_BYTES) {
+            return null;
+          }
+          const res = await fetchFn(`${ctx.toolsUrl}/artifacts/${value.id}`, {
+            headers: authHeaders3,
+            signal: ctx.signal
+          });
+          if (!res.ok) return null;
+          const data = await readCapped(res, value.size);
+          if (!data || data.length !== value.size) return null;
+          const finalPath = await writeDurableUnique(
+            saveTarget.dir,
+            filename,
+            (p) => writeFile4(p, data, { flag: "wx" })
+          );
+          if (!finalPath) return null;
+          if (value.mimeType.startsWith("image/")) {
+            images.push({ localPath: finalPath, data, mimeType: value.mimeType });
+          }
+          return finalPath;
+        } catch {
+          return null;
+        }
+      }
+      if (localPath) {
+        if (value.mimeType.startsWith("image/")) {
+          images.push({ localPath, data: await readFile4(localPath), mimeType: value.mimeType });
+        }
+        return localPath;
+      }
+      try {
+        const res = await fetchFn(`${ctx.toolsUrl}/artifacts/${value.id}`, {
+          headers: authHeaders3,
+          signal: ctx.signal
+        });
+        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 = join9(dir, sanitizeSegment(value.filename));
+        await writeFile4(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;
+}
+
+// src/bundled-paths.ts
+import * as fs5 from "node:fs";
+import * as path9 from "node:path";
+function readPackageVersion() {
+  try {
+    const pkg = JSON.parse(
+      fs5.readFileSync(path9.join(import.meta.dirname, "..", "package.json"), "utf8")
+    );
+    return pkg.version;
+  } catch {
+    return void 0;
+  }
+}
+var PACKAGE_NAME = "@swmansion/argent";
+function findDeclaringRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (fs5.existsSync(path9.join(dir, ".argent", "install.json"))) return dir;
+    try {
+      const manifest = JSON.parse(fs5.readFileSync(path9.join(dir, "package.json"), "utf8"));
+      if (manifest.devDependencies?.[PACKAGE_NAME] || manifest.dependencies?.[PACKAGE_NAME] || manifest.optionalDependencies?.[PACKAGE_NAME]) {
+        return dir;
+      }
+    } catch {
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function findStablePackageDir(startDir, packageRoot) {
+  let dir = startDir;
+  for (; ; ) {
+    const candidate = path9.join(dir, "node_modules", PACKAGE_NAME);
+    try {
+      if (fs5.realpathSync(candidate) === packageRoot) return candidate;
+    } catch {
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function classifyInstall() {
+  let packageRoot;
+  let dir;
+  let cwd;
+  try {
+    packageRoot = fs5.realpathSync(path9.join(import.meta.dirname, ".."));
+    cwd = process.cwd();
+    dir = cwd;
+  } catch {
+    return { kind: "global" };
+  }
+  for (; ; ) {
+    try {
+      const nmReal = fs5.realpathSync(path9.join(dir, "node_modules"));
+      if (packageRoot === nmReal || packageRoot.startsWith(nmReal + path9.sep)) {
+        return {
+          kind: "local",
+          projectRoot: findDeclaringRoot(cwd) ?? dir,
+          stablePackageDir: findStablePackageDir(cwd, packageRoot)
+        };
+      }
+    } catch {
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (packageRoot.includes(`${path9.sep}.yarn${path9.sep}`)) {
+    const declRoot = findDeclaringRoot(cwd);
+    if (declRoot) return { kind: "local", projectRoot: declRoot };
+  }
+  return { kind: "global" };
+}
+var classifiedInstall = classifyInstall();
+var packageDir = classifiedInstall.stablePackageDir ?? path9.join(import.meta.dirname, "..");
+var BUNDLED_RUNTIME_PATHS = {
+  bundlePath: path9.join(packageDir, "dist", "tool-server.cjs"),
+  simulatorServerDir: path9.join(packageDir, "bin"),
+  nativeDevtoolsDir: path9.join(packageDir, "dylibs"),
+  version: readPackageVersion(),
+  installKind: classifiedInstall.kind,
+  installProjectRoot: classifiedInstall.projectRoot
+};
+
+// src/client.ts
+var ArgentToolError = class extends Error {
+  /** Stable failure code, when the server sent one. */
+  code;
+  /** Failure category, e.g. "subprocess", when the server sent one. */
+  kind;
+  /** Schema issues of a rejected argument object; set only on a validation failure. */
+  issues;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "ArgentToolError";
+    this.code = details.code;
+    this.kind = details.kind;
+    this.issues = details.issues;
+  }
+};
+function listFlags() {
+  return FLAG_REGISTRY.map(({ name, description }) => ({
+    name,
+    description,
+    enabled: isFeatureEnabled(name)
+  }));
+}
+function createArgentClient() {
+  let client = createToolsClient({ paths: BUNDLED_RUNTIME_PATHS });
+  async function stopServer() {
+    const stopped = await killToolServer(BUNDLED_RUNTIME_PATHS.bundlePath);
+    client = createToolsClient({ paths: BUNDLED_RUNTIME_PATHS });
+    return stopped;
+  }
+  async function listTools(options) {
+    const tools = await client.fetchTools({ signal: options?.signal });
+    return tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+  }
+  async function callTool(name, args = {}, options) {
+    try {
+      const response = await client.callTool(name, args, options);
+      const { url, token } = await client.baseUrl();
+      options?.signal?.throwIfAborted();
+      const { result } = await materializeArtifacts(response.data, {
+        toolsUrl: url,
+        authToken: token,
+        deviceId: getDeviceIdFromArgs(args),
+        signal: options?.signal
+      });
+      options?.signal?.throwIfAborted();
+      return { data: result, note: response.note };
+    } catch (err) {
+      if (err instanceof ToolInvocationError) {
+        throw new ArgentToolError(err.message, {
+          code: err.errorCode,
+          kind: err.errorKind,
+          issues: err.issues
+        });
+      }
+      throw err;
+    }
+  }
+  return { listTools, callTool, stopServer };
+}
+export {
+  ArgentToolError,
+  createArgentClient,
+  listFlags
+};