@uipath/codedagent-tool 1.199.0 → 1.201.0-preview.115

package/dist/tool-kst857r2.js

@@ -0,0 +1,3184 @@
+import {
+  COMMAND_RULES,
+  OutputFormatter,
+  RESULTS,
+  WHITELISTED_COMMANDS,
+  catchError,
+  codedAgentCommandPreflight,
+  createExecuteCommand,
+  createSetupCommand,
+  extractErrorMessageSync,
+  processContext,
+  trackShipSucceeded
+} from "./tool-thn7hw7k.js";
+import {
+  getFileSystem
+} from "./tool-7eva0peq.js";
+import {
+  __require
+} from "./tool-0v6na3yp.js";
+// package.json
+var package_default = {
+  name: "@uipath/codedagent-tool",
+  license: "MIT",
+  version: "1.201.0-preview.115",
+  description: "Build, run, deploy, and manage AI Agents.",
+  keywords: [
+    "cli-tool",
+    "codedagents",
+    "wrapper"
+  ],
+  type: "module",
+  main: "./dist/tool.js",
+  exports: {
+    ".": "./dist/tool.js",
+    "./init": {
+      types: "./dist/init.d.ts",
+      default: "./dist/init.js"
+    }
+  },
+  private: false,
+  bin: {
+    "codedagent-tool": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/codedagent-tool"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  scripts: {
+    build: "bun ../../tools/build-tool.ts && tsc -p tsconfig.build.json --noCheck",
+    package: "bun run build && bun pm pack",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    lint: "biome check .",
+    "lint:fix": "biome check --write ."
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.2",
+    "@uipath/agent-reviewer-sdk": "workspace:*",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/llmgw-sdk": "workspace:*",
+    "@uipath/uipath-python-bridge": "workspace:*",
+    commander: "^14.0.3",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../agent-reviewer-sdk/dist/index.js
+var KNOWN_CATEGORIES = [
+  "evals",
+  "schema",
+  "tools",
+  "guardrails",
+  "code",
+  "general"
+];
+function listCategories() {
+  return [...KNOWN_CATEGORIES];
+}
+async function loadFile(fs, path) {
+  const raw = await fs.readFile(path, "utf-8");
+  if (raw === null) {
+    return { present: false };
+  }
+  return { present: true, raw };
+}
+function parseJsonObject(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return null;
+}
+function resolveEntryPyPath(langgraphJson) {
+  if (langgraphJson.present) {
+    const graphs = parseJsonObject(langgraphJson.raw)?.graphs;
+    const graphsObj = typeof graphs === "object" && graphs !== null && !Array.isArray(graphs) ? graphs : undefined;
+    for (const spec of Object.values(graphsObj ?? {})) {
+      if (typeof spec === "string") {
+        const filePart = spec.split(":")[0]?.replace(/^\.\//, "").trim();
+        if (filePart?.endsWith(".py")) {
+          return filePart;
+        }
+      }
+    }
+  }
+  return "main.py";
+}
+async function loadCodedProjectContext(projectPath, fs) {
+  const uipathJsonPath = fs.path.join(projectPath, "uipath.json");
+  const pyprojectPath = fs.path.join(projectPath, "pyproject.toml");
+  const entryPointsPath = fs.path.join(projectPath, "entry-points.json");
+  const mainPyPath = fs.path.join(projectPath, "main.py");
+  const langgraphJsonPath = fs.path.join(projectPath, "langgraph.json");
+  const [uipathJson, pyproject, entryPoints, mainPyExists, langgraphJson] = await Promise.all([
+    loadFile(fs, uipathJsonPath),
+    loadFile(fs, pyprojectPath),
+    loadFile(fs, entryPointsPath),
+    fs.exists(mainPyPath),
+    loadFile(fs, langgraphJsonPath)
+  ]);
+  const entrySourcePath = resolveEntryPyPath(langgraphJson);
+  const entrySource = await loadFile(fs, fs.path.join(projectPath, entrySourcePath));
+  return {
+    projectPath,
+    kind: "coded",
+    uipathJson,
+    pyproject,
+    entryPoints,
+    mainPy: { present: mainPyExists },
+    langgraphJson,
+    entrySource,
+    entrySourcePath
+  };
+}
+var PENALTY_PER_ERROR = 15;
+var PENALTY_PER_WARNING = 4;
+var PENALTY_PER_INFO = 1;
+var BONUS_PER_STRENGTH = 1;
+var BONUS_CAP = 5;
+var PASS_FAIL_THRESHOLD = 50;
+var FAIL_GRADE_CAP = "C+";
+var GRADE_CHART = [
+  [100, "A+"],
+  [90, "A"],
+  [85, "A-"],
+  [80, "B+"],
+  [70, "B"],
+  [65, "B-"],
+  [60, "C+"],
+  [50, "C"],
+  [45, "C-"],
+  [40, "D+"],
+  [30, "D"],
+  [25, "D-"],
+  [0, "F"]
+];
+var GRADE_RANK = new Map(GRADE_CHART.map(([, grade], index) => [grade, index]));
+var ZERO_CATEGORY_COUNTS = () => ({
+  evals: 0,
+  schema: 0,
+  tools: 0,
+  guardrails: 0,
+  code: 0,
+  general: 0
+});
+function lookupGrade(score) {
+  for (const [threshold, grade] of GRADE_CHART) {
+    if (score >= threshold) {
+      return grade;
+    }
+  }
+  return "F";
+}
+function rankOf(grade) {
+  return GRADE_RANK.get(grade) ?? GRADE_CHART.length - 1;
+}
+function clamp(value, lo, hi) {
+  return Math.max(lo, Math.min(hi, value));
+}
+function assertExhaustive(value) {
+  throw new Error(`Unhandled severity: ${String(value)}`);
+}
+function buildStats(issues) {
+  const byCategory = ZERO_CATEGORY_COUNTS();
+  let errors = 0;
+  let warnings = 0;
+  let infos = 0;
+  for (const issue of issues) {
+    byCategory[issue.category] += 1;
+    const severity = issue.severity;
+    switch (severity) {
+      case "error":
+        errors += 1;
+        break;
+      case "warning":
+        warnings += 1;
+        break;
+      case "info":
+        infos += 1;
+        break;
+      default:
+        assertExhaustive(severity);
+    }
+  }
+  return { errors, warnings, infos, byCategory };
+}
+function computeReviewResult(issues, strengths) {
+  const stats = buildStats(issues);
+  const penalty = PENALTY_PER_ERROR * stats.errors + PENALTY_PER_WARNING * stats.warnings + PENALTY_PER_INFO * stats.infos;
+  const bonus = stats.errors === 0 ? Math.min(BONUS_CAP, BONUS_PER_STRENGTH * strengths.length) : 0;
+  const score = clamp(100 - penalty + bonus, 0, 100);
+  const verdict = stats.errors > 0 || score < PASS_FAIL_THRESHOLD ? "FAIL" : "PASS";
+  let grade = lookupGrade(score);
+  if (verdict === "FAIL" && rankOf(grade) < rankOf(FAIL_GRADE_CAP)) {
+    grade = FAIL_GRADE_CAP;
+  }
+  return {
+    verdict,
+    score,
+    grade,
+    issues,
+    strengths,
+    stats
+  };
+}
+async function runRules(rules, context, fs, options) {
+  let selected = rules;
+  if (options.categories !== undefined) {
+    const known = new Set(KNOWN_CATEGORIES);
+    const unknown = options.categories.filter((c) => !known.has(c));
+    if (unknown.length > 0) {
+      return { ok: false, error: "UNKNOWN_CATEGORIES", unknown };
+    }
+    const filter = new Set(options.categories);
+    selected = rules.filter((rule) => filter.has(rule.category));
+  }
+  const issues = [];
+  for (const rule of selected) {
+    let ruleIssues;
+    try {
+      ruleIssues = await rule.run(context, fs);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      issues.push({
+        ruleId: "RULE_RUNTIME_ERROR",
+        category: "general",
+        severity: "error",
+        description: `Rule '${rule.id}' threw an unhandled error: ${message}`,
+        element: rule.id
+      });
+      continue;
+    }
+    for (const ruleIssue of ruleIssues) {
+      issues.push({
+        ruleId: rule.id,
+        category: rule.category,
+        severity: rule.severity,
+        ...ruleIssue
+      });
+    }
+  }
+  return { ok: true, result: computeReviewResult(issues, []) };
+}
+var SHARED_RULES = [];
+var codedPyprojectMissing = {
+  id: "PYPROJECT_TOML_MISSING",
+  category: "code",
+  severity: "error",
+  run: async (ctx) => {
+    if (ctx.pyproject.present) {
+      return [];
+    }
+    return [
+      {
+        description: "Coded agent project is missing `pyproject.toml`.",
+        file: "pyproject.toml",
+        suggestedFix: "Add a `pyproject.toml` declaring the project's Python dependencies and metadata."
+      }
+    ];
+  }
+};
+var SCOPE_MAP = {
+  AGENT: "Agent",
+  LLM: "Llm",
+  TOOL: "Tool"
+};
+function balancedArgs(source, openParen) {
+  let depth = 0;
+  let quote = null;
+  for (let i = openParen;i < source.length; i++) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        return source.slice(openParen + 1, i);
+      }
+    }
+  }
+  return "";
+}
+function nameArg(args) {
+  const m = /\bname\s*=\s*["']([^"']*)["']/.exec(args);
+  return m?.[1] && m[1].length > 0 ? m[1] : "<unnamed>";
+}
+function stringKwarg(args, key) {
+  return new RegExp(`\\b${key}\\s*=\\s*["']([^"']*)["']`).exec(args)?.[1];
+}
+function actionClassArg(args) {
+  return /\baction\s*=\s*([A-Za-z_]\w*)\s*\(/.exec(args)?.[1];
+}
+function scopeArgs(args) {
+  const m = /\bscopes\s*=\s*\[([^\]]*)\]/.exec(args);
+  if (!m?.[1]) {
+    return [];
+  }
+  const out = [];
+  for (const sm of m[1].matchAll(/GuardrailScope\.([A-Z_]+)/g)) {
+    const mapped = SCOPE_MAP[sm[1]];
+    if (mapped !== undefined && !out.includes(mapped)) {
+      out.push(mapped);
+    }
+  }
+  return out;
+}
+function findCalls(source, classRe) {
+  const out = [];
+  for (const m of source.matchAll(classRe)) {
+    const className = m[1];
+    const openParen = m.index + m[0].length - 1;
+    out.push({ className, args: balancedArgs(source, openParen) });
+  }
+  return out;
+}
+function resolveValidatorClass(validatorExpr, source) {
+  const inline = /^\s*([A-Z]\w*)\s*\(/.exec(validatorExpr);
+  if (inline?.[1]) {
+    return inline[1];
+  }
+  const ident = /^\s*([A-Za-z_]\w*)\s*$/.exec(validatorExpr)?.[1];
+  if (ident !== undefined) {
+    const assign = new RegExp(`\\b${ident}\\s*=\\s*([A-Z]\\w*)\\s*\\(`).exec(source);
+    return assign?.[1];
+  }
+  return;
+}
+function collectLocalClasses(source) {
+  const out = new Map;
+  for (const m of source.matchAll(/^\s*class\s+([A-Za-z_]\w*)\s*(?:\(([^)]*)\))?\s*:/gm)) {
+    const name = m[1];
+    const bases = (m[2] ?? "").split(",").filter((b) => !b.includes("=") && !b.includes("*")).map((b) => b.trim().replace(/\[.*$/, "").split(".").pop()).filter((b) => b.length > 0);
+    out.set(name, bases);
+  }
+  return out;
+}
+function extractCodedGuardrails(entrySource, pyprojectRaw) {
+  const source = entrySource ?? "";
+  const guardrails = [];
+  for (const { className, args } of findCalls(source, /\b(UiPath[A-Za-z]*Middleware)\s*\(/g)) {
+    guardrails.push({
+      label: nameArg(args),
+      style: "middleware",
+      className,
+      actionClass: actionClassArg(args),
+      scopes: scopeArgs(args),
+      hasTools: /\btools\s*=\s*\[/.test(args),
+      model: stringKwarg(args, "model")
+    });
+  }
+  for (const m of source.matchAll(/@guardrail\s*\(/g)) {
+    const args = balancedArgs(source, m.index + m[0].length - 1);
+    const validatorExpr = /\bvalidator\s*=\s*([\s\S]*?)(?:,\s*(?:action|stage|name)\s*=|$)/.exec(args)?.[1];
+    const className = validatorExpr !== undefined ? resolveValidatorClass(validatorExpr, source) ?? "<unknown>" : "<unknown>";
+    guardrails.push({
+      label: nameArg(args),
+      style: "decorator",
+      className,
+      actionClass: actionClassArg(args),
+      scopes: [],
+      hasTools: /\btools\s*=\s*\[/.test(args),
+      model: stringKwarg(args, "model")
+    });
+  }
+  const isLangChain = /\bfrom\s+langchain[\w.]*\s+import\b|\bfrom\s+langgraph[\w.]*\s+import\b|\bimport\s+langgraph\b/.test(source) || /uipath[-_]langchain/.test(pyprojectRaw ?? "");
+  return {
+    guardrails,
+    isLangChain,
+    importsGuardrailFromPlatform: /(?:from|import)\s+uipath\.platform\.guardrails\b/.test(source),
+    importsGuardrailFromLangchain: /(?:from|import)\s+uipath_langchain\.guardrails\b/.test(source),
+    localClasses: collectLocalClasses(source)
+  };
+}
+var extractionCache = new WeakMap;
+function codedGuardrailExtraction(ctx) {
+  const cached = extractionCache.get(ctx);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const extraction = extractCodedGuardrails(ctx.entrySource.present ? ctx.entrySource.raw : undefined, ctx.pyproject.present ? ctx.pyproject.raw : undefined);
+  extractionCache.set(ctx, extraction);
+  return extraction;
+}
+function subclassesAny(className, targets, localClasses, seen = new Set) {
+  if (seen.has(className)) {
+    return false;
+  }
+  seen.add(className);
+  const bases = localClasses.get(className);
+  if (bases === undefined) {
+    return false;
+  }
+  return bases.some((b) => targets.includes(b) || subclassesAny(b, targets, localClasses, seen));
+}
+var VALIDATOR_BASES = [
+  "GuardrailValidatorBase",
+  "BuiltInGuardrailValidator",
+  "CustomGuardrailValidator"
+];
+var codedGuardrailInvalidContract = {
+  id: "CODED_GUARDRAIL_INVALID_CONTRACT",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    const { guardrails, localClasses } = codedGuardrailExtraction(ctx);
+    return guardrails.flatMap((g) => {
+      const issues = [];
+      if (g.actionClass !== undefined && localClasses.has(g.actionClass) && !subclassesAny(g.actionClass, ["GuardrailAction"], localClasses)) {
+        issues.push({
+          description: `Guardrail \`${g.label}\` uses action class \`${g.actionClass}\`, which does not subclass \`GuardrailAction\` — a custom action must extend it and implement \`handle_validation_result\`, or it fails at runtime.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Make the action class subclass `GuardrailAction` from the guardrails SDK and implement `handle_validation_result`."
+        });
+      }
+      if (g.style === "decorator" && localClasses.has(g.className) && !subclassesAny(g.className, VALIDATOR_BASES, localClasses)) {
+        issues.push({
+          description: `Guardrail \`${g.label}\` uses validator class \`${g.className}\`, which does not subclass a guardrail validator base — use \`CustomValidator(...)\` or subclass \`GuardrailValidatorBase\` / \`CustomGuardrailValidator\`, or it fails at runtime.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Use `CustomValidator(...)` for an in-process rule, or subclass `BuiltInGuardrailValidator` / `CustomGuardrailValidator`."
+        });
+      }
+      return issues;
+    });
+  }
+};
+var codedGuardrailLlmJudgeModelInvalid = {
+  id: "CODED_GUARDRAIL_LLM_JUDGE_MODEL_INVALID",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    if (ctx.llmJudgeModels === undefined) {
+      return [];
+    }
+    const allowed = new Set(ctx.llmJudgeModels);
+    const available = [...allowed].sort((a, b) => a.localeCompare(b));
+    const evidence = available.length > 0 ? `Available models: ${available.join(", ")}` : "No models are available for the LLM-as-judge guardrail on this tenant.";
+    return codedGuardrailExtraction(ctx).guardrails.flatMap((g) => {
+      const value = g.model;
+      if (value === undefined || value.length === 0) {
+        return [];
+      }
+      if (allowed.has(value)) {
+        return [];
+      }
+      return [
+        {
+          description: `LLM-as-judge guardrail \`${g.label}\` uses model \`${value}\`, which is not available for this tenant's LLM Gateway.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          evidences: [evidence],
+          suggestedFix: "Set the `model=` argument to a ModelId listed by `uip agent guardrails llm-as-judge-models`."
+        }
+      ];
+    });
+  }
+};
+var codedGuardrailToolScopeNoTools = {
+  id: "CODED_GUARDRAIL_TOOL_SCOPE_NO_TOOLS",
+  category: "guardrails",
+  severity: "warning",
+  run: async (ctx) => {
+    return codedGuardrailExtraction(ctx).guardrails.flatMap((g) => {
+      if (g.style !== "middleware" || !g.scopes.includes("Tool") || g.hasTools) {
+        return [];
+      }
+      return [
+        {
+          description: `Tool-scoped guardrail \`${g.label}\` passes no \`tools=[...]\`, so it has no tool to attach to and will not fire.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Pass the `@tool` objects this guardrail should guard via `tools=[my_tool, …]`."
+        }
+      ];
+    });
+  }
+};
+var codedGuardrailWrongImport = {
+  id: "CODED_GUARDRAIL_WRONG_IMPORT",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    const extraction = codedGuardrailExtraction(ctx);
+    if (!extraction.isLangChain || !extraction.importsGuardrailFromPlatform || extraction.importsGuardrailFromLangchain) {
+      return [];
+    }
+    return [
+      {
+        description: "This LangChain agent imports guardrail symbols from `uipath.platform.guardrails`. " + "The LangChain adapter is only registered by importing from `uipath_langchain.guardrails`, " + "so as written the guardrails never wrap the LLM/tool/agent and silently do nothing at runtime.",
+        file: ctx.entrySourcePath,
+        evidences: ["from uipath.platform.guardrails import …"],
+        suggestedFix: "Import guardrail symbols from `uipath_langchain.guardrails` (not `uipath.platform.guardrails`) " + "so the LangChain adapter wraps the decorated/middleware objects."
+      }
+    ];
+  }
+};
+var CODED_RULES = [
+  codedPyprojectMissing,
+  codedGuardrailWrongImport,
+  codedGuardrailToolScopeNoTools,
+  codedGuardrailInvalidContract,
+  codedGuardrailLlmJudgeModelInvalid
+];
+async function reviewCodedAgent(projectPath, options, fs) {
+  const loaded = await loadCodedProjectContext(projectPath, fs);
+  const context = {
+    ...loaded,
+    llmJudgeModels: options.llmJudgeModels
+  };
+  return runRules([...SHARED_RULES, ...CODED_RULES], context, fs, options);
+}
+var CLASSIFIER_FIELD_NAMES = new Set([
+  "class",
+  "classification",
+  "label",
+  "category",
+  "intent"
+]);
+var TOOL_LIKE_RESOURCE_TYPES = new Set([
+  "tool",
+  "escalation",
+  "context",
+  "mcp"
+]);
+var CUSTOM_RULE_TYPES = new Set([
+  "word",
+  "number",
+  "boolean",
+  "always"
+]);
+var SELECTOR_TYPES = new Set(["all", "specific"]);
+var WORD_OPERATORS = new Set([
+  "contains",
+  "equals",
+  "startsWith",
+  "endsWith",
+  "matchesRegex",
+  "doesNotContain",
+  "doesNotEqual",
+  "doesNotStartWith",
+  "doesNotEndWith",
+  "isEmpty",
+  "isNotEmpty"
+]);
+var WORD_VALUELESS_OPERATORS = new Set([
+  "isEmpty",
+  "isNotEmpty"
+]);
+var NUMBER_OPERATORS = new Set([
+  "equals",
+  "doesNotEqual",
+  "greaterThan",
+  "greaterThanOrEqual",
+  "lessThan",
+  "lessThanOrEqual"
+]);
+var BOOLEAN_OPERATORS = new Set(["equals"]);
+
+// ../admin/llmgw-sdk/dist/index.js
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import fs2 from "node:fs";
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+import process3 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import childProcess2 from "node:child_process";
+import fs4, { constants as fsConstants } from "node:fs/promises";
+import { promisify as promisify3 } from "node:util";
+import process4 from "node:process";
+import { execFile as execFile3 } from "node:child_process";
+import process5 from "node:process";
+import { promisify as promisify4 } from "node:util";
+import { execFile as execFile4, execFileSync } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile6 } from "node:child_process";
+import process7 from "node:process";
+import process8 from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import childProcess3 from "node:child_process";
+import fs5, { constants as fsConstants2 } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import * as fs6 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require2 = /* @__PURE__ */ createRequire(import.meta.url);
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError2(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [
+      error instanceof Error ? error : new Error(String(error)),
+      undefined
+    ];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+var UIPATH_HOME_DIR = ".uipath";
+var AUTH_FILENAME = ".auth";
+var DEFAULT_BASE_URL = "https://cloud.uipath.com";
+var DEFAULT_AUTH_TIMEOUT_MS;
+var init_constants = __esm(() => {
+  DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+});
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && "document" in globalThis;
+}
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = () => {};
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var init_is_inside_container = __esm(() => {
+  init_is_docker();
+});
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default;
+var init_is_wsl = __esm(() => {
+  init_is_inside_container();
+  is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+});
+var execFile;
+var powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+var init_powershell_utils = __esm(() => {
+  execFile = promisify(childProcess.execFile);
+  executePowerShell.argumentsPrefix = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand"
+  ];
+  executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+  executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+});
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+var execFile2;
+var wslDrivesMountPoint;
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var powerShellPath2;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+};
+var convertWslPathToWindows = async (path3) => {
+  if (/^[a-z]+:\/\//i.test(path3)) {
+    return path3;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path3], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path3;
+  }
+};
+var init_wsl_utils = __esm(() => {
+  init_is_wsl();
+  init_powershell_utils();
+  init_is_wsl();
+  execFile2 = promisify2(childProcess2.execFile);
+  wslDrivesMountPoint = (() => {
+    const defaultMountPoint = "/mnt/";
+    let mountPoint;
+    return async function() {
+      if (mountPoint) {
+        return mountPoint;
+      }
+      const configFilePath = "/etc/wsl.conf";
+      let isConfigFileExists = false;
+      try {
+        await fs4.access(configFilePath, fsConstants.F_OK);
+        isConfigFileExists = true;
+      } catch {}
+      if (!isConfigFileExists) {
+        return defaultMountPoint;
+      }
+      const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+      const parsedMountPoint = parseMountPointFromConfig(configContent);
+      if (parsedMountPoint === undefined) {
+        return defaultMountPoint;
+      }
+      mountPoint = parsedMountPoint;
+      mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+      return mountPoint;
+    };
+  })();
+  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+});
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = __esm(() => {
+  execFileAsync = promisify3(execFile3);
+});
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = __esm(() => {
+  execFileAsync2 = promisify4(execFile4);
+});
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm(() => {
+  init_run_applescript();
+});
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var execFileAsync3;
+var windowsBrowserProgIds;
+var _windowsBrowserProgIdMap;
+var UnknownBrowserError;
+var init_windows = __esm(() => {
+  execFileAsync3 = promisify5(execFile5);
+  windowsBrowserProgIds = {
+    MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+    MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+    MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+    ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+    ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+    ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+    ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+    BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+    BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+    BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+    BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+    FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+    OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+    VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+    "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+  };
+  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+  UnknownBrowserError = class UnknownBrowserError2 extends Error {
+  };
+});
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4;
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+var init_default_browser = __esm(() => {
+  init_default_browser_id();
+  init_bundle_name();
+  init_windows();
+  init_windows();
+  execFileAsync4 = promisify6(execFile6);
+});
+var isInSsh;
+var is_in_ssh_default;
+var init_is_in_ssh = __esm(() => {
+  isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+  is_in_ssh_default = isInSsh;
+});
+var exports_open = {};
+__export(exports_open, {
+  openApp: () => openApp,
+  default: () => open_default,
+  apps: () => apps
+});
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var fallbackAttemptSymbol;
+var __dirname2;
+var localXdgOpenPath;
+var platform;
+var arch;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return tryEachApp(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      },
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "com.brave.browser": "brave",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
+    if (browser.id in ids) {
+      const browserName = ids[browser.id.toLowerCase()];
+      if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process8.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve2, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve2(subprocess);
+      });
+    });
+  }
+  if (isFallbackAttempt) {
+    return new Promise((resolve2, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve2(subprocess);
+        });
+      });
+    });
+  }
+  subprocess.unref();
+  return new Promise((resolve2, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve2(subprocess);
+    });
+  });
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+var openApp = (name, options) => {
+  if (typeof name !== "string" && !Array.isArray(name)) {
+    throw new TypeError("Expected a valid `name`");
+  }
+  const { arguments: appArguments = [] } = options ?? {};
+  if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
+    throw new TypeError("Expected `appArguments` as Array type");
+  }
+  return baseOpen({
+    ...options,
+    app: {
+      name,
+      arguments: appArguments
+    }
+  });
+};
+var apps;
+var open_default;
+var init_open = __esm(() => {
+  init_wsl_utils();
+  init_powershell_utils();
+  init_default_browser();
+  init_is_inside_container();
+  init_is_in_ssh();
+  fallbackAttemptSymbol = Symbol("fallbackAttempt");
+  __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+  localXdgOpenPath = path.join(__dirname2, "xdg-open");
+  ({ platform, arch } = process8);
+  apps = {
+    browser: "browser",
+    browserPrivate: "browserPrivate"
+  };
+  defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+    darwin: "google chrome",
+    win32: "chrome",
+    linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+      x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+    darwin: "brave browser",
+    win32: "brave",
+    linux: ["brave-browser", "brave"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+      x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+    darwin: "firefox",
+    win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+    linux: "firefox"
+  }, {
+    wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+  }));
+  defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+    darwin: "microsoft edge",
+    win32: "msedge",
+    linux: ["microsoft-edge", "microsoft-edge-dev"]
+  }, {
+    wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+  }));
+  defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+    darwin: "Safari"
+  }));
+  open_default = open;
+});
+
+class NodeFileSystem {
+  path = {
+    join: path2.join,
+    resolve: path2.resolve,
+    relative: path2.relative,
+    dirname: path2.dirname,
+    isAbsolute: path2.isAbsolute,
+    basename: path2.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os2.homedir,
+    tmpdir: os2.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      const { default: open2 } = await Promise.resolve().then(() => (init_open(), exports_open));
+      await open2(url);
+    }
+  };
+  async readFile(path3, options) {
+    try {
+      if (options) {
+        return await fs6.readFile(path3, "utf-8");
+      }
+      return await fs6.readFile(path3);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs6.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs6.mkdir(dirPath, { recursive: true });
+  }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs6.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs6.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs6.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path2.resolve(lockPath);
+    const fullReal = await fs6.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path2.dirname(absolute);
+    const base = path2.basename(absolute);
+    const canonicalParent = await fs6.realpath(parent).catch(() => parent);
+    return path2.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
+      }
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs6.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs6.rm(lockFile, { force: true });
+      }
+    };
+  }
+  async rm(filePath) {
+    await fs6.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs6.rename(oldPath, newPath);
+  }
+  async realpath(filePath) {
+    try {
+      return await fs6.realpath(filePath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return filePath;
+      throw error;
+    }
+  }
+  async getTempDir() {
+    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path2.join(sourcePath, entry);
+      const destEntry = path2.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  }
+}
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+var init_node = () => {};
+var fsInstance;
+var getFileSystem2 = () => fsInstance;
+var init_src = __esm(() => {
+  init_node();
+  init_node();
+  fsInstance = new NodeFileSystem;
+});
+init_constants();
+var DEFAULT_CLIENT_ID = "36dea5b8-e8bb-423d-8e7b-c808df8f1c00";
+var AUTH_FILE_CONFIG_KEY = Symbol.for("@uipath/auth/AuthFileConfig");
+var globalSlot = globalThis;
+var getAuthFileConfig = () => globalSlot[AUTH_FILE_CONFIG_KEY] ?? {};
+
+class InvalidBaseUrlError extends Error {
+  url;
+  reason;
+  constructor(url, reason) {
+    super(`Invalid base URL: "${url}"
+` + `Reason: ${reason}
+
+` + `Expected format: an https:// URL, e.g. https://cloud.uipath.com (commercial), https://govcloud.uipath.us (Public Sector), or your Automation Suite host (https://<your-host>).
+` + `You can specify the URL via:
+` + `  • --authority flag
+` + `  • UIPATH_URL environment variable
+` + `  • auth.authority in config file`);
+    this.url = url;
+    this.reason = reason;
+    this.name = "InvalidBaseUrlError";
+  }
+}
+var DEFAULT_SCOPES = ["openid", "profile", "offline_access"];
+var normalizeAndValidateBaseUrl = (rawUrl) => {
+  let baseUrl = rawUrl;
+  if (baseUrl.endsWith("/identity_/")) {
+    baseUrl = baseUrl.slice(0, -11);
+  } else if (baseUrl.endsWith("/identity_")) {
+    baseUrl = baseUrl.slice(0, -10);
+  }
+  while (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  const resolvedBaseUrl = baseUrl;
+  const [urlError, url] = catchError2(() => new URL(resolvedBaseUrl));
+  if (urlError) {
+    throw new InvalidBaseUrlError(baseUrl, `Malformed URL. ${urlError instanceof Error ? urlError.message : "Unknown error"}`);
+  }
+  if (url.protocol !== "https:") {
+    throw new InvalidBaseUrlError(baseUrl, `Authority must use https:// scheme, got ${url.protocol}//. OIDC token exchange requires TLS end-to-end.`);
+  }
+  return url.pathname.length > 1 ? url.origin : baseUrl;
+};
+var resolveScopes = (isExternalAppAuth, customScopes, fileScopes) => {
+  const requestedScopes = customScopes?.length ? customScopes : fileScopes ?? [];
+  if (isExternalAppAuth)
+    return requestedScopes;
+  return [...new Set([...DEFAULT_SCOPES, ...requestedScopes])];
+};
+var resolveConfigAsync = async ({
+  customAuthority,
+  customClientId,
+  customClientSecret,
+  customClientAssertion,
+  customScopes
+} = {}) => {
+  const fileAuth = getAuthFileConfig();
+  let baseUrl = customAuthority;
+  if (!baseUrl) {
+    baseUrl = process.env.UIPATH_URL;
+  }
+  if (!baseUrl && fileAuth.authority) {
+    baseUrl = fileAuth.authority;
+  }
+  if (!baseUrl) {
+    baseUrl = DEFAULT_BASE_URL;
+  }
+  baseUrl = normalizeAndValidateBaseUrl(baseUrl);
+  let clientId = customClientId;
+  if (!clientId && fileAuth.clientId) {
+    clientId = fileAuth.clientId;
+  }
+  if (!clientId) {
+    clientId = DEFAULT_CLIENT_ID;
+  }
+  let clientSecret = customClientSecret;
+  if (!clientSecret && fileAuth.clientSecret) {
+    clientSecret = fileAuth.clientSecret;
+  }
+  const isExternalAppAuth = clientId !== DEFAULT_CLIENT_ID && (Boolean(clientSecret) || Boolean(customClientAssertion));
+  const scopes = resolveScopes(isExternalAppAuth, customScopes, fileAuth.scopes);
+  return {
+    clientId,
+    clientSecret,
+    scopes,
+    baseUrl,
+    authorizationEndpoint: `${baseUrl}/identity_/connect/authorize`,
+    tokenEndpoint: `${baseUrl}/identity_/connect/token`
+  };
+};
+init_constants();
+init_src();
+init_src();
+init_constants();
+var DEFAULT_AUTH_PROFILE = "default";
+var PROFILE_DIR = "profiles";
+var PROFILE_NAME_RE = /^[A-Za-z0-9._-]+$/;
+var ACTIVE_AUTH_PROFILE_KEY = Symbol.for("@uipath/auth/ActiveAuthProfile");
+var AUTH_PROFILE_STORAGE_KEY = Symbol.for("@uipath/auth/ProfileStorage");
+var globalSlot2 = globalThis;
+function isAuthProfileStorage(value) {
+  return value !== null && typeof value === "object" && "getStore" in value && "run" in value;
+}
+function createProfileStorage() {
+  const [error, mod] = catchError2(() => __require2("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
+    return {
+      getStore: () => {
+        return;
+      },
+      run: (_store, fn) => fn()
+    };
+  }
+  return new mod.AsyncLocalStorage;
+}
+function getProfileStorage() {
+  const existing = globalSlot2[AUTH_PROFILE_STORAGE_KEY];
+  if (isAuthProfileStorage(existing)) {
+    return existing;
+  }
+  const storage = createProfileStorage();
+  globalSlot2[AUTH_PROFILE_STORAGE_KEY] = storage;
+  return storage;
+}
+var profileStorage = getProfileStorage();
+
+class AuthProfileValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthProfileValidationError";
+  }
+}
+function normalizeAuthProfileName(profile) {
+  if (profile === undefined || profile === DEFAULT_AUTH_PROFILE) {
+    return;
+  }
+  if (profile.length === 0 || profile === "." || profile === ".." || !PROFILE_NAME_RE.test(profile)) {
+    throw new AuthProfileValidationError(`Invalid profile name "${profile}". Profile names may contain only letters, numbers, '.', '_', and '-'.`);
+  }
+  return profile;
+}
+function getActiveAuthProfile() {
+  const scopedState = profileStorage.getStore();
+  if (scopedState !== undefined) {
+    return scopedState.profile;
+  }
+  return globalSlot2[ACTIVE_AUTH_PROFILE_KEY]?.profile;
+}
+function resolveAuthProfileFilePath(profile) {
+  const normalized = normalizeAuthProfileName(profile);
+  if (normalized === undefined) {
+    throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile file path.`);
+  }
+  const fs7 = getFileSystem2();
+  return fs7.path.join(fs7.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
+}
+function getActiveAuthProfileFilePath() {
+  const profile = getActiveAuthProfile();
+  return profile ? resolveAuthProfileFilePath(profile) : undefined;
+}
+
+class InvalidIssuerError extends Error {
+  expected;
+  actual;
+  constructor(expected, actual) {
+    const actualText = actual ?? "<missing>";
+    super(`Token issuer does not match the authority used to log in.
+` + `Expected: ${expected}
+` + `Actual:   ${actualText}
+
+` + `The identity server that issued this token is not the one ` + `you pointed --authority at. Refusing to save credentials.`);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "InvalidIssuerError";
+  }
+}
+var parseJWT = (token) => {
+  try {
+    const parts = token.split(".");
+    const base64Url = parts[1];
+    if (!base64Url) {
+      throw new Error("Invalid JWT token format - missing payload section");
+    }
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    let decodedString;
+    if (isBrowser() && typeof atob !== "undefined") {
+      decodedString = atob(base64);
+    } else {
+      decodedString = Buffer.from(base64, "base64").toString();
+    }
+    const jsonPayload = decodeURIComponent(decodedString.split("").map((c) => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`).join(""));
+    const parsed = JSON.parse(jsonPayload);
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to parse JWT: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+};
+var assertIssuerMatchesAuthority = (token, authority) => {
+  let payload;
+  try {
+    payload = parseJWT(token);
+  } catch (error) {
+    throw new InvalidIssuerError(`${authority.replace(/\/+$/, "")}/identity_`, `<unparseable: ${error instanceof Error ? error.message : "unknown error"}>`);
+  }
+  const stripTrailingSlash = (s) => s.replace(/\/+$/, "");
+  const expected = `${stripTrailingSlash(authority)}/identity_`;
+  const actual = typeof payload.iss === "string" ? stripTrailingSlash(payload.iss) : undefined;
+  if (actual !== expected) {
+    throw new InvalidIssuerError(expected, payload.iss);
+  }
+};
+var getTokenExpiration = (accessToken) => {
+  try {
+    const parts = accessToken.split(".");
+    if (parts.length !== 3) {
+      return;
+    }
+    const payload = parts[1];
+    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const decoded = atob(padded);
+    const claims = JSON.parse(decoded);
+    if (typeof claims.exp !== "number") {
+      return;
+    }
+    return new Date(claims.exp * 1000);
+  } catch {
+    return;
+  }
+};
+var parseAuthFlow = (value) => value === "authorization_code" || value === "client_credentials" || value === "federated_credentials" ? value : undefined;
+var decodeClaims = (accessToken) => {
+  const [error, claims] = catchError2(() => parseJWT(accessToken));
+  return error ? undefined : claims;
+};
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var resolveIdentityType = (claims, authFlow, email) => {
+  const subType = asString(claims?.sub_type);
+  if (subType) {
+    return subType.startsWith("service") ? "Application" : "User";
+  }
+  if (authFlow) {
+    return authFlow === "authorization_code" ? "User" : "Application";
+  }
+  if (email)
+    return "User";
+  if (asString(claims?.client_id) && !asString(claims?.sub)) {
+    return "Application";
+  }
+  return;
+};
+var looksLikeEmail = (value) => value?.includes("@") ?? false;
+var pickEmail = (claims) => {
+  for (const candidate of [claims?.email, claims?.preferred_username]) {
+    const value = asString(candidate);
+    if (looksLikeEmail(value))
+      return value;
+  }
+  return;
+};
+var pickName = (claims) => {
+  const username = asString(claims?.preferred_username);
+  return asString(claims?.name) ?? (looksLikeEmail(username) ? undefined : username);
+};
+var resolveSessionIdentity = (accessToken, authFlow) => {
+  const claims = accessToken ? decodeClaims(accessToken) : undefined;
+  const email = pickEmail(claims);
+  const type = resolveIdentityType(claims, authFlow, email);
+  if (!type)
+    return;
+  const identity = { type };
+  if (authFlow)
+    identity.authFlow = authFlow;
+  if (type === "User") {
+    const userId = asString(claims?.sub);
+    if (userId)
+      identity.userId = userId;
+    if (email)
+      identity.userEmail = email;
+    const name = pickName(claims);
+    if (name)
+      identity.userName = name;
+    return identity;
+  }
+  const clientId = asString(claims?.client_id);
+  if (clientId)
+    identity.clientId = clientId;
+  return identity;
+};
+var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
+var ENFORCE_ROBOT_AUTH_VAR = "UIPATH_CLI_ENFORCE_ROBOT_AUTH";
+var ENV_AUTH_VARS = {
+  token: "UIPATH_CLI_AUTH_TOKEN",
+  organizationName: "UIPATH_CLI_ORGANIZATION_NAME",
+  organizationId: "UIPATH_CLI_ORGANIZATION_ID",
+  tenantName: "UIPATH_CLI_TENANT_NAME",
+  tenantId: "UIPATH_CLI_TENANT_ID"
+};
+
+class EnvAuthConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EnvAuthConfigError";
+  }
+}
+var isEnvAuthEnabled = () => process.env[ENV_AUTH_ENABLE_VAR] === "true";
+var isRobotAuthEnforced = () => process.env[ENFORCE_ROBOT_AUTH_VAR] === "true";
+var requireEnv = (name) => {
+  const value = process.env[name];
+  if (!value) {
+    throw new EnvAuthConfigError(`${ENV_AUTH_ENABLE_VAR}=true but ${name} is not set. ` + `Set ${name} to enable env-var authentication.`);
+  }
+  return value;
+};
+var readAuthFromEnv = () => {
+  const accessToken = requireEnv(ENV_AUTH_VARS.token);
+  const organizationName = requireEnv(ENV_AUTH_VARS.organizationName);
+  const organizationId = requireEnv(ENV_AUTH_VARS.organizationId);
+  const tenantName = requireEnv(ENV_AUTH_VARS.tenantName);
+  const tenantId = requireEnv(ENV_AUTH_VARS.tenantId);
+  const [parseError, payload] = catchError2(() => parseJWT(accessToken));
+  if (parseError) {
+    throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a valid JWT: ` + `${parseError instanceof Error ? parseError.message : String(parseError)}`);
+  }
+  const iss = payload.iss;
+  if (typeof iss !== "string" || iss.length === 0) {
+    throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} has no 'iss' claim; cannot determine ` + `the UiPath server. Ensure the token was issued by a UiPath identity server.`);
+  }
+  const [baseUrlError, baseUrl] = catchError2(() => normalizeAndValidateBaseUrl(iss));
+  if (baseUrlError) {
+    if (baseUrlError instanceof InvalidBaseUrlError) {
+      throw baseUrlError;
+    }
+    throw new EnvAuthConfigError(`Failed to derive server URL from token 'iss' claim: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
+  }
+  const expiration = getTokenExpiration(accessToken);
+  const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
+  const identity = resolveSessionIdentity(accessToken);
+  return {
+    loginStatus,
+    accessToken,
+    baseUrl,
+    organizationName,
+    organizationId,
+    tenantName,
+    tenantId,
+    expiration,
+    source: "env-vars",
+    ...identity ? { identity } : {}
+  };
+};
+init_src();
+var BREAKER_SUFFIX = ".refresh-state";
+var BACKOFF_BASE_MS = 60000;
+var BACKOFF_CAP_MS = 60 * 60 * 1000;
+var SURFACE_WINDOW_MS = 60 * 60 * 1000;
+async function refreshTokenFingerprint(refreshToken) {
+  const bytes = new TextEncoder().encode(refreshToken);
+  if (globalThis.crypto?.subtle) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
+  }
+  const { createHash } = await import("node:crypto");
+  return createHash("sha256").update(refreshToken).digest("hex").slice(0, 16);
+}
+function breakerPathFor(authPath) {
+  return `${authPath}${BREAKER_SUFFIX}`;
+}
+async function loadRefreshBreaker(authPath) {
+  const fs7 = getFileSystem2();
+  try {
+    const content = await fs7.readFile(breakerPathFor(authPath), "utf-8");
+    if (!content)
+      return {};
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function saveRefreshBreaker(authPath, state) {
+  try {
+    const fs7 = getFileSystem2();
+    const path3 = breakerPathFor(authPath);
+    await fs7.mkdir(fs7.path.dirname(path3));
+    const tempPath = `${path3}.tmp`;
+    await fs7.writeFile(tempPath, JSON.stringify(state));
+    await fs7.rename(tempPath, path3);
+  } catch {}
+}
+async function clearRefreshBreaker(authPath) {
+  const fs7 = getFileSystem2();
+  const path3 = breakerPathFor(authPath);
+  try {
+    if (await fs7.exists(path3)) {
+      await fs7.rm(path3);
+    }
+  } catch {}
+}
+function nextBackoffMs(attempts) {
+  const shift = Math.max(0, attempts - 1);
+  return Math.min(BACKOFF_BASE_MS * 2 ** shift, BACKOFF_CAP_MS);
+}
+function shouldSurface(state, nowMs) {
+  if (state.lastSurfacedAtMs === undefined)
+    return true;
+  return nowMs - state.lastSurfacedAtMs >= SURFACE_WINDOW_MS;
+}
+init_src();
+var DEFAULT_TIMEOUT_MS = 1000;
+var CLOSE_TIMEOUT_MS = 500;
+var ROBOT_USER_SERVICES_PIPE = "UiPathUserServices";
+var ROBOT_USER_SERVICES_ALTERNATE_PIPE = `${ROBOT_USER_SERVICES_PIPE}Alternate`;
+var PIPE_NAME_MAX_LENGTH = 103;
+var getRobotIpcPipeNames = async () => {
+  const fs7 = getFileSystem2();
+  const username = fs7.env.getenv("USER") ?? fs7.env.getenv("USERNAME");
+  if (!username) {
+    throw new Error("Unable to determine current username");
+  }
+  const tempPath = fs7.env.getenv("TMPDIR") ?? "/tmp/";
+  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs7.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
+};
+var defaultIsRobotIpcAvailable = async () => {
+  if (process.platform === "win32") {
+    return true;
+  }
+  const [pipeNamesError, pipeNames] = await catchError2(getRobotIpcPipeNames());
+  if (pipeNamesError || !pipeNames) {
+    return false;
+  }
+  const fs7 = getFileSystem2();
+  for (const pipeName of pipeNames) {
+    const [existsError, exists] = await catchError2(fs7.exists(pipeName));
+    if (!existsError && exists === true) {
+      return true;
+    }
+  }
+  return false;
+};
+var withTimeout = (promise, timeoutMs) => new Promise((resolve2, reject) => {
+  const timer = setTimeout(() => reject(new Error(`Robot IPC call timed out after ${timeoutMs}ms`)), timeoutMs);
+  promise.then((value) => {
+    clearTimeout(timer);
+    resolve2(value);
+  }, (error) => {
+    clearTimeout(timer);
+    reject(error);
+  });
+});
+var parseResourceUrl = (url) => {
+  const [error, parsed] = catchError2(() => new URL(url));
+  if (error || !parsed)
+    return;
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  return {
+    baseUrl: parsed.origin,
+    organizationName: segments[0],
+    tenantName: segments[1]
+  };
+};
+var ROBOT_CLIENT_LOADER_KEY = Symbol.for("@uipath/auth/RobotClientLoader");
+var getRegisteredRobotClientLoader = () => {
+  const loader = globalThis[ROBOT_CLIENT_LOADER_KEY];
+  return typeof loader === "function" ? loader : undefined;
+};
+var defaultLoadModule = async () => {
+  const hostLoader = getRegisteredRobotClientLoader();
+  if (!hostLoader) {
+    return;
+  }
+  const [error, mod] = await catchError2(() => hostLoader());
+  if (error || !mod) {
+    return;
+  }
+  return mod;
+};
+var tryRobotClientFallback = async (options = {}) => {
+  if (isBrowser())
+    return;
+  if (!options.force) {
+    if (process.env.CI || process.env.GITHUB_ACTIONS) {
+      return;
+    }
+    if (process.env.UIPATH_URL) {
+      return;
+    }
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const isRobotIpcAvailable = options.isRobotIpcAvailable ?? defaultIsRobotIpcAvailable;
+  const loadModule = options.loadModule ?? defaultLoadModule;
+  if (!await isRobotIpcAvailable()) {
+    return;
+  }
+  const mod = await loadModule();
+  if (!mod)
+    return;
+  const [ctorError, proxy] = catchError2(() => new mod.RobotProxyConstructor);
+  if (ctorError || !proxy) {
+    return;
+  }
+  try {
+    const enabled = await withTimeout(proxy.interactiveConnectFlow.IsEnabled(), timeoutMs);
+    if (!enabled) {
+      return;
+    }
+    const [resourceUrl, accessToken] = await Promise.all([
+      withTimeout(proxy.accessProvider.GetResourceUrl("Orchestrator"), timeoutMs),
+      withTimeout(proxy.accessProvider.GetAccessToken("Orchestrator", false), timeoutMs)
+    ]);
+    if (!accessToken) {
+      return;
+    }
+    const parsedUrl = parseResourceUrl(resourceUrl);
+    if (!parsedUrl) {
+      return;
+    }
+    let organizationIdFromToken;
+    let tenantIdFromToken;
+    let issuerFromToken;
+    const [jwtError, claims] = catchError2(() => parseJWT(accessToken));
+    if (!jwtError && claims) {
+      const rawOrgId = claims.prtId ?? claims.organizationId ?? claims.prt_id;
+      if (typeof rawOrgId === "string" && rawOrgId.length > 0) {
+        organizationIdFromToken = rawOrgId;
+      }
+      const tenantClaim = claims.tenantId ?? claims.tenant_id;
+      if (typeof tenantClaim === "string" && tenantClaim.length > 0) {
+        tenantIdFromToken = tenantClaim;
+      }
+      const issClaim = claims.iss;
+      if (typeof issClaim === "string" && issClaim.length > 0) {
+        issuerFromToken = issClaim;
+      }
+    }
+    return {
+      accessToken,
+      baseUrl: parsedUrl.baseUrl,
+      organizationName: parsedUrl.organizationName,
+      organizationId: organizationIdFromToken ?? parsedUrl.organizationName,
+      tenantName: parsedUrl.tenantName,
+      tenantId: tenantIdFromToken,
+      issuer: issuerFromToken
+    };
+  } catch {
+    return;
+  } finally {
+    await catchError2(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
+  }
+};
+var TOKEN_REFRESH_REAUTHENTICATE_MESSAGE = "Token refresh failed. Run 'uip login' to re-authenticate.";
+
+class TokenRefreshOAuthError extends Error {
+  __brand = "TokenRefreshOAuthError";
+  constructor() {
+    super(TOKEN_REFRESH_REAUTHENTICATE_MESSAGE);
+    this.name = "TokenRefreshOAuthError";
+  }
+}
+function isTokenRefreshOAuthFailure(error) {
+  return error instanceof TokenRefreshOAuthError;
+}
+var refreshAccessToken = async ({
+  refreshToken,
+  tokenEndpoint,
+  clientId,
+  expectedAuthority
+}) => {
+  const tokenParams = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId
+  });
+  const tokenResponse = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: tokenParams
+  });
+  const tokenData = await tokenResponse.json();
+  if (!tokenResponse.ok) {
+    throw new TokenRefreshOAuthError;
+  }
+  const newAccessToken = tokenData.access_token;
+  const newRefreshToken = tokenData.refresh_token;
+  if (typeof newAccessToken !== "string" || typeof newRefreshToken !== "string") {
+    throw new Error("Token refresh response is missing access_token or refresh_token");
+  }
+  if (expectedAuthority) {
+    assertIssuerMatchesAuthority(newAccessToken, expectedAuthority);
+  }
+  return { accessToken: newAccessToken, refreshToken: newRefreshToken };
+};
+var AUTH_FLOW_ENV_VAR = "UIPATH_AUTH_FLOW";
+init_src();
+init_constants();
+var DEFAULT_ENV_FILENAME = `${UIPATH_HOME_DIR}/${AUTH_FILENAME}`;
+var KNOWN_ERROR_CODES = new Set([
+  "EISDIR",
+  "EACCES",
+  "EPERM",
+  "ELOOP",
+  "ENOTDIR",
+  "EUNKNOWN"
+]);
+var errorCode = (err) => {
+  if (err !== null && typeof err === "object" && "code" in err && typeof err.code === "string") {
+    const raw = err.code;
+    return KNOWN_ERROR_CODES.has(raw) ? raw : "EUNKNOWN";
+  }
+  return "EUNKNOWN";
+};
+var probeAsync = async (fs7, candidate) => {
+  try {
+    const stats = await fs7.stat(candidate);
+    if (stats === null) {
+      return { exists: false };
+    }
+    if (!stats.isFile()) {
+      return {
+        exists: false,
+        unusable: {
+          reason: "not-a-file",
+          code: "EISDIR",
+          message: `Path is not a regular file: ${candidate}`
+        }
+      };
+    }
+    return { exists: true };
+  } catch (err) {
+    return {
+      exists: false,
+      unusable: {
+        reason: "unreadable",
+        code: errorCode(err),
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+};
+var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
+  const fs7 = getFileSystem2();
+  if (fs7.path.isAbsolute(envFilePath)) {
+    const probe2 = await probeAsync(fs7, envFilePath);
+    return probe2.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
+      exists: false,
+      absolutePath: envFilePath,
+      source: "absolute",
+      ...probe2.unusable ? { unusable: probe2.unusable } : {}
+    };
+  }
+  const cwd = opts?.cwd ?? fs7.env.cwd();
+  let searchDir = cwd;
+  while (true) {
+    const candidate = fs7.path.join(searchDir, envFilePath);
+    const probe2 = await probeAsync(fs7, candidate);
+    if (probe2.exists) {
+      return {
+        exists: true,
+        absolutePath: candidate,
+        source: searchDir === cwd ? "cwd" : "ancestor"
+      };
+    }
+    const parentDir = fs7.path.dirname(searchDir);
+    if (parentDir === searchDir) {
+      break;
+    }
+    searchDir = parentDir;
+  }
+  const homePath = fs7.path.join(fs7.env.homedir(), envFilePath);
+  const probe = await probeAsync(fs7, homePath);
+  if (probe.exists) {
+    return { exists: true, absolutePath: homePath, source: "home" };
+  }
+  return {
+    exists: false,
+    absolutePath: homePath,
+    source: "default",
+    ...probe.unusable ? { unusable: probe.unusable } : {}
+  };
+};
+var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
+  const location = await resolveEnvFileLocationAsync(envFilePath, opts);
+  if (location.exists) {
+    return { absolutePath: location.absolutePath };
+  }
+  return {
+    absolutePath: undefined,
+    errorMessage: location.source === "absolute" ? `Environment file not found: ${envFilePath}` : `Unable to locate environment file: ${envFilePath}. Run 'uip login' to authenticate.`
+  };
+};
+var loadEnvFileAsync = async ({ envPath }) => {
+  const fs7 = getFileSystem2();
+  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.cwd(), envPath);
+  if (!await fs7.exists(absolutePath)) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  const content = await fs7.readFile(absolutePath, "utf-8");
+  if (content === null) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  const env = {};
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, equalIndex).trim();
+    let value = trimmed.slice(equalIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+};
+var saveEnvFileAsync = async ({
+  envPath,
+  data,
+  merge = true
+}) => {
+  const fs7 = getFileSystem2();
+  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.homedir(), envPath);
+  let existingData = {};
+  if (merge && await fs7.exists(absolutePath)) {
+    try {
+      existingData = await loadEnvFileAsync({ envPath: absolutePath });
+    } catch {}
+  }
+  const finalData = { ...existingData, ...data };
+  const lines = [];
+  for (const [key, value] of Object.entries(finalData)) {
+    if (value === undefined) {
+      continue;
+    }
+    const needsQuotes = value.includes(" ") || value.includes("#");
+    const finalValue = needsQuotes ? `"${value}"` : value;
+    lines.push(`${key}=${finalValue}`);
+  }
+  const content = `${lines.join(`
+`)}
+`;
+  const dir = fs7.path.dirname(absolutePath);
+  await fs7.mkdir(dir);
+  const tempPath = `${absolutePath}.tmp`;
+  await fs7.writeFile(tempPath, content);
+  await fs7.rename(tempPath, absolutePath);
+};
+var getLoginStatusAsync = async (options = {}) => {
+  return getLoginStatusWithDeps(options);
+};
+var getLoginStatusWithDeps = async (options = {}, deps = {}) => {
+  const {
+    resolveEnvFilePath = resolveEnvFilePathAsync,
+    loadEnvFile = loadEnvFileAsync,
+    saveEnvFile = saveEnvFileAsync,
+    getFs = getFileSystem2,
+    refreshToken: refreshTokenFn = refreshAccessToken,
+    resolveConfig = resolveConfigAsync,
+    robotFallback = tryRobotClientFallback,
+    loadBreaker = loadRefreshBreaker,
+    saveBreaker = saveRefreshBreaker,
+    clearBreaker = clearRefreshBreaker
+  } = deps;
+  if (isRobotAuthEnforced()) {
+    return resolveRobotEnforcedStatus(robotFallback);
+  }
+  if (isEnvAuthEnabled()) {
+    return readAuthFromEnv();
+  }
+  const activeProfile = getActiveAuthProfile();
+  const activeProfileFilePath = getActiveAuthProfileFilePath();
+  const usingActiveProfile = activeProfile !== undefined && (options.envFilePath === undefined || options.envFilePath === activeProfileFilePath);
+  const envFilePath = options.envFilePath ?? activeProfileFilePath ?? DEFAULT_ENV_FILENAME;
+  const { ensureTokenValidityMinutes } = options;
+  const { absolutePath } = await resolveEnvFilePath(envFilePath);
+  if (absolutePath === undefined) {
+    if (usingActiveProfile) {
+      return {
+        loginStatus: "Not logged in",
+        hint: `No credentials found for profile "${activeProfile}". Run 'uip login --profile ${activeProfile}' to authenticate this profile.`
+      };
+    }
+    return resolveBorrowedRobotStatus(robotFallback);
+  }
+  const loaded = await loadFileCredentials(loadEnvFile, absolutePath);
+  if ("status" in loaded) {
+    return loaded.status;
+  }
+  const { credentials } = loaded;
+  const globalHint = () => usingActiveProfile ? Promise.resolve(undefined) : getGlobalCredsHint(getFs, loadEnvFile, absolutePath, envFilePath);
+  const expiration = getTokenExpiration(credentials.UIPATH_ACCESS_TOKEN);
+  const outerThreshold = computeExpirationThreshold(ensureTokenValidityMinutes);
+  let tokens = {
+    accessToken: credentials.UIPATH_ACCESS_TOKEN,
+    refreshToken: credentials.UIPATH_REFRESH_TOKEN,
+    expiration,
+    lockReleaseFailed: false
+  };
+  const refreshToken = credentials.UIPATH_REFRESH_TOKEN;
+  if (expiration && expiration <= outerThreshold && refreshToken) {
+    const refreshed = await attemptRefresh({
+      absolutePath,
+      credentials,
+      accessToken: credentials.UIPATH_ACCESS_TOKEN,
+      refreshToken,
+      expiration,
+      ensureTokenValidityMinutes,
+      getFs,
+      loadEnvFile,
+      saveEnvFile,
+      refreshFn: refreshTokenFn,
+      resolveConfig,
+      loadBreaker,
+      saveBreaker,
+      clearBreaker,
+      globalHint
+    });
+    if (refreshed.kind === "terminal") {
+      return refreshed.status;
+    }
+    tokens = refreshed.tokens;
+  }
+  return buildFileStatus(tokens, credentials, globalHint);
+};
+async function resolveRobotEnforcedStatus(robotFallback) {
+  if (isEnvAuthEnabled()) {
+    throw new EnvAuthConfigError(`${ENV_AUTH_ENABLE_VAR}=true and ${ENFORCE_ROBOT_AUTH_VAR}=true are mutually exclusive. Unset one of them and re-run.`);
+  }
+  const robotCreds = await robotFallback({ force: true });
+  if (!robotCreds) {
+    return {
+      loginStatus: "Not logged in",
+      hint: `${ENFORCE_ROBOT_AUTH_VAR}=true but the UiPath Robot session is unavailable. Start and sign in to the Assistant, or unset ${ENFORCE_ROBOT_AUTH_VAR} to fall back to file or env-var authentication.`
+    };
+  }
+  return buildRobotStatus(robotCreds);
+}
+async function resolveBorrowedRobotStatus(robotFallback) {
+  const robotCreds = await robotFallback();
+  return robotCreds ? buildRobotStatus(robotCreds) : { loginStatus: "Not logged in" };
+}
+async function loadFileCredentials(loadEnvFile, absolutePath) {
+  let credentials;
+  try {
+    credentials = await loadEnvFile({ envPath: absolutePath });
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return { status: { loginStatus: "Not logged in" } };
+    }
+    throw error;
+  }
+  if (!credentials.UIPATH_ACCESS_TOKEN) {
+    return { status: { loginStatus: "Not logged in" } };
+  }
+  return { credentials };
+}
+async function getGlobalCredsHint(getFs, loadEnvFile, absolutePath, envFilePath) {
+  const fs7 = getFs();
+  const globalPath = fs7.path.join(fs7.env.homedir(), envFilePath);
+  if (absolutePath === globalPath)
+    return;
+  if (!await fs7.exists(globalPath))
+    return;
+  try {
+    const globalCreds = await loadEnvFile({ envPath: globalPath });
+    if (!globalCreds.UIPATH_ACCESS_TOKEN)
+      return;
+    const globalExp = getTokenExpiration(globalCreds.UIPATH_ACCESS_TOKEN);
+    if (globalExp && globalExp <= new Date)
+      return;
+    return `Local credentials file at ${absolutePath} has expired credentials. Valid credentials exist in ${globalPath}. Remove the local file or run 'uip login' to re-authenticate.`;
+  } catch {
+    return;
+  }
+}
+function computeExpirationThreshold(ensureTokenValidityMinutes) {
+  return new Date(Date.now() + (ensureTokenValidityMinutes ?? 0) * 60 * 1000);
+}
+async function attemptRefresh(ctx) {
+  const shortCircuit = await circuitBreakerShortCircuit(ctx);
+  if (shortCircuit) {
+    return { kind: "terminal", status: shortCircuit };
+  }
+  let release;
+  try {
+    release = await ctx.getFs().acquireLock(ctx.absolutePath);
+  } catch (error) {
+    return {
+      kind: "terminal",
+      status: await lockAcquireFailureStatus(ctx, error)
+    };
+  }
+  let lockedFailure;
+  let lockReleaseFailed = false;
+  let success;
+  try {
+    const outcome = await runRefreshLocked({
+      absolutePath: ctx.absolutePath,
+      refreshToken: ctx.refreshToken,
+      customAuthority: ctx.credentials.UIPATH_URL,
+      ensureTokenValidityMinutes: ctx.ensureTokenValidityMinutes,
+      loadEnvFile: ctx.loadEnvFile,
+      saveEnvFile: ctx.saveEnvFile,
+      refreshFn: ctx.refreshFn,
+      resolveConfig: ctx.resolveConfig,
+      loadBreaker: ctx.loadBreaker,
+      saveBreaker: ctx.saveBreaker,
+      clearBreaker: ctx.clearBreaker
+    });
+    if (outcome.kind === "fail") {
+      lockedFailure = outcome.status;
+    } else {
+      success = outcome;
+    }
+  } finally {
+    try {
+      await release();
+    } catch {
+      lockReleaseFailed = true;
+    }
+  }
+  if (lockedFailure) {
+    const globalHint = await ctx.globalHint();
+    const base = globalHint ? { ...lockedFailure, loginStatus: "Expired", hint: globalHint } : lockedFailure;
+    return {
+      kind: "terminal",
+      status: lockReleaseFailed ? { ...base, lockReleaseFailed: true } : base
+    };
+  }
+  return {
+    kind: "refreshed",
+    tokens: {
+      accessToken: success?.accessToken,
+      refreshToken: success?.refreshToken,
+      expiration: success?.expiration,
+      tokenRefresh: success?.tokenRefresh,
+      persistenceWarning: success?.persistenceWarning,
+      lockReleaseFailed
+    }
+  };
+}
+async function buildFileStatus(tokens, credentials, globalHint) {
+  const result = {
+    loginStatus: tokens.expiration && tokens.expiration <= new Date ? "Expired" : "Logged in",
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    baseUrl: credentials.UIPATH_URL,
+    organizationName: credentials.UIPATH_ORGANIZATION_NAME,
+    organizationId: credentials.UIPATH_ORGANIZATION_ID,
+    tenantName: credentials.UIPATH_TENANT_NAME,
+    tenantId: credentials.UIPATH_TENANT_ID,
+    expiration: tokens.expiration,
+    source: "saved-login",
+    ...identityFields(tokens.accessToken, credentials),
+    ...tokens.persistenceWarning ? { hint: tokens.persistenceWarning, persistenceFailed: true } : {},
+    ...tokens.lockReleaseFailed ? { lockReleaseFailed: true } : {},
+    ...tokens.tokenRefresh ? { tokenRefresh: tokens.tokenRefresh } : {}
+  };
+  if (result.loginStatus === "Expired") {
+    const hint = await globalHint();
+    if (hint) {
+      result.hint = hint;
+    }
+  }
+  return result;
+}
+function identityFields(accessToken, credentials) {
+  const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
+  return identity ? { identity } : {};
+}
+function buildRobotStatus(robotCreds) {
+  const identity = resolveSessionIdentity(robotCreds.accessToken);
+  return {
+    loginStatus: "Logged in",
+    accessToken: robotCreds.accessToken,
+    baseUrl: robotCreds.baseUrl,
+    organizationName: robotCreds.organizationName,
+    organizationId: robotCreds.organizationId,
+    tenantName: robotCreds.tenantName,
+    tenantId: robotCreds.tenantId,
+    issuer: robotCreds.issuer,
+    expiration: getTokenExpiration(robotCreds.accessToken),
+    source: "robot",
+    ...identity ? { identity } : {}
+  };
+}
+var isFileNotFoundError = (error) => {
+  if (!(error instanceof Object))
+    return false;
+  return error.code === "ENOENT";
+};
+async function circuitBreakerShortCircuit(ctx) {
+  const {
+    absolutePath,
+    refreshToken,
+    accessToken,
+    credentials,
+    expiration,
+    loadBreaker,
+    saveBreaker,
+    clearBreaker
+  } = ctx;
+  const fingerprint = await refreshTokenFingerprint(refreshToken);
+  const breaker = await loadBreaker(absolutePath).catch(() => ({}));
+  if (breaker.deadTokenFp && breaker.deadTokenFp !== fingerprint) {
+    await clearBreaker(absolutePath);
+    breaker.deadTokenFp = undefined;
+  }
+  const nowMs = Date.now();
+  const tokenIsDead = breaker.deadTokenFp === fingerprint;
+  const inBackoff = breaker.backoffUntilMs !== undefined && nowMs < breaker.backoffUntilMs;
+  if (!tokenIsDead && !inBackoff)
+    return;
+  const globalHint = await ctx.globalHint();
+  const suppressed = !shouldSurface(breaker, nowMs);
+  if (!suppressed) {
+    await saveBreaker(absolutePath, {
+      ...breaker,
+      lastSurfacedAtMs: nowMs
+    });
+  }
+  const deadHint = "Run 'uip login' to re-authenticate — the stored refresh token is invalid or expired. In a non-interactive context, authenticate with: uip login --client-id <id> --client-secret <secret> -t <tenant>.";
+  const backoffHint = "Token refresh is temporarily backed off after a recent network error and will retry automatically once the backoff window elapses.";
+  return {
+    loginStatus: globalHint ? "Expired" : "Refresh Failed",
+    ...globalHint ? {
+      accessToken,
+      refreshToken,
+      baseUrl: credentials.UIPATH_URL,
+      organizationName: credentials.UIPATH_ORGANIZATION_NAME,
+      organizationId: credentials.UIPATH_ORGANIZATION_ID,
+      tenantName: credentials.UIPATH_TENANT_NAME,
+      tenantId: credentials.UIPATH_TENANT_ID,
+      expiration,
+      source: "saved-login",
+      ...identityFields(accessToken, credentials)
+    } : {},
+    hint: globalHint ?? (tokenIsDead ? deadHint : backoffHint),
+    refreshCircuitOpen: true,
+    refreshTelemetrySuppressed: suppressed,
+    tokenRefresh: { attempted: false, success: false }
+  };
+}
+async function lockAcquireFailureStatus(ctx, error) {
+  const msg = errorMessage(error);
+  const globalHint = await ctx.globalHint();
+  if (globalHint) {
+    return {
+      loginStatus: "Expired",
+      accessToken: ctx.accessToken,
+      refreshToken: ctx.refreshToken,
+      baseUrl: ctx.credentials.UIPATH_URL,
+      organizationName: ctx.credentials.UIPATH_ORGANIZATION_NAME,
+      organizationId: ctx.credentials.UIPATH_ORGANIZATION_ID,
+      tenantName: ctx.credentials.UIPATH_TENANT_NAME,
+      tenantId: ctx.credentials.UIPATH_TENANT_ID,
+      expiration: ctx.expiration,
+      source: "saved-login",
+      ...identityFields(ctx.accessToken, ctx.credentials),
+      hint: globalHint,
+      tokenRefresh: {
+        attempted: false,
+        success: false,
+        errorMessage: `lock acquisition failed: ${msg}`
+      }
+    };
+  }
+  return {
+    loginStatus: "Refresh Failed",
+    hint: "Could not acquire the auth-file lock — too many concurrent `uip` processes, or a permission issue on the auth directory. Retry, or run 'uip login' to re-authenticate.",
+    tokenRefresh: {
+      attempted: false,
+      success: false,
+      errorMessage: `lock acquisition failed: ${msg}`
+    }
+  };
+}
+async function runRefreshLocked(inputs) {
+  const {
+    absolutePath,
+    refreshToken: callerRefreshToken,
+    customAuthority,
+    ensureTokenValidityMinutes,
+    loadEnvFile,
+    saveEnvFile,
+    refreshFn,
+    resolveConfig,
+    loadBreaker,
+    saveBreaker,
+    clearBreaker
+  } = inputs;
+  const expirationThreshold = computeExpirationThreshold(ensureTokenValidityMinutes);
+  let fresh;
+  try {
+    fresh = await loadEnvFile({ envPath: absolutePath });
+  } catch (error) {
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint: "Could not read the auth file while refreshing. Retry, or run 'uip login' to re-authenticate.",
+        tokenRefresh: {
+          attempted: false,
+          success: false,
+          errorMessage: `auth file read failed: ${errorMessage(error)}`
+        }
+      }
+    };
+  }
+  const freshAccess = fresh.UIPATH_ACCESS_TOKEN;
+  const freshExp = freshAccess ? getTokenExpiration(freshAccess) : undefined;
+  if (freshAccess && freshExp && freshExp > expirationThreshold) {
+    await clearBreaker(absolutePath);
+    return {
+      kind: "ok",
+      accessToken: freshAccess,
+      refreshToken: fresh.UIPATH_REFRESH_TOKEN ?? callerRefreshToken,
+      expiration: freshExp,
+      tokenRefresh: { attempted: false, success: true }
+    };
+  }
+  const tokenForIdP = fresh.UIPATH_REFRESH_TOKEN ?? callerRefreshToken;
+  let refreshedAccess;
+  let refreshedRefresh;
+  try {
+    const config = await resolveConfig({ customAuthority });
+    const refreshed = await refreshFn({
+      refreshToken: tokenForIdP,
+      tokenEndpoint: config.tokenEndpoint,
+      clientId: config.clientId,
+      expectedAuthority: customAuthority
+    });
+    refreshedAccess = refreshed.accessToken;
+    refreshedRefresh = refreshed.refreshToken;
+  } catch (error) {
+    const isOAuthFailure = isTokenRefreshOAuthFailure(error);
+    const hint = isOAuthFailure ? "Run 'uip login' to re-authenticate — the stored refresh token is invalid or expired. In a non-interactive context, authenticate with: uip login --client-id <id> --client-secret <secret> -t <tenant>." : "Token refresh failed. Check your network connection, then retry or run 'uip login' to re-authenticate.";
+    const message = isOAuthFailure ? normalizeTokenRefreshFailure() : normalizeTokenRefreshUnavailableFailure();
+    const fp = await refreshTokenFingerprint(tokenForIdP);
+    if (isOAuthFailure) {
+      await saveBreaker(absolutePath, { deadTokenFp: fp });
+    } else {
+      const prior = await loadBreaker(absolutePath).catch(() => ({}));
+      const attempts = (prior.attempts ?? 0) + 1;
+      await saveBreaker(absolutePath, {
+        ...prior,
+        deadTokenFp: undefined,
+        attempts,
+        backoffUntilMs: Date.now() + nextBackoffMs(attempts)
+      });
+    }
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint,
+        tokenRefresh: {
+          attempted: true,
+          success: false,
+          errorMessage: message
+        }
+      }
+    };
+  }
+  const refreshedExp = getTokenExpiration(refreshedAccess);
+  if (!refreshedExp || refreshedExp <= new Date) {
+    return {
+      kind: "fail",
+      status: {
+        loginStatus: "Refresh Failed",
+        hint: "The identity server returned an unusable token. Run 'uip login' to re-authenticate.",
+        tokenRefresh: {
+          attempted: true,
+          success: false,
+          errorMessage: "refreshed token has no valid expiration claim"
+        }
+      }
+    };
+  }
+  await clearBreaker(absolutePath);
+  try {
+    await saveEnvFile({
+      envPath: absolutePath,
+      data: {
+        UIPATH_ACCESS_TOKEN: refreshedAccess,
+        UIPATH_REFRESH_TOKEN: refreshedRefresh
+      },
+      merge: true
+    });
+    return {
+      kind: "ok",
+      accessToken: refreshedAccess,
+      refreshToken: refreshedRefresh,
+      expiration: refreshedExp,
+      tokenRefresh: { attempted: true, success: true }
+    };
+  } catch (error) {
+    const msg = errorMessage(error);
+    return {
+      kind: "ok",
+      accessToken: refreshedAccess,
+      refreshToken: refreshedRefresh,
+      expiration: refreshedExp,
+      persistenceWarning: `Access token refreshed in memory but could not be written to ${absolutePath}: ${msg}. The next CLI invocation will fail until the file can be updated — run 'uip login' to re-authenticate.`,
+      tokenRefresh: {
+        attempted: true,
+        success: true,
+        errorMessage: `persistence failed: ${msg}`
+      }
+    };
+  }
+}
+function normalizeTokenRefreshFailure() {
+  return "stored refresh token is invalid or expired";
+}
+function normalizeTokenRefreshUnavailableFailure() {
+  return "token refresh failed before authentication completed";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+init_constants();
+init_src();
+var TENANT_SELECTION_REQUIRED_CODE = "TENANT_SELECTION_REQUIRED";
+var INVALID_TENANT_CODE = "INVALID_TENANT";
+var TENANT_SELECTION_CODES = new Set([
+  TENANT_SELECTION_REQUIRED_CODE,
+  INVALID_TENANT_CODE
+]);
+init_src();
+var SERVICE_PATH = {
+  "llm-gateway": "llmgateway_"
+};
+var REQUESTING_PRODUCT = "uipath-cli";
+async function resolveStatus(options) {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options?.loginValidity
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  return {
+    status,
+    bearerToken: options?.s2sToken ?? status.accessToken
+  };
+}
+function stripTrailingSlash(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === s.length ? s : s.slice(0, end);
+}
+function buildUrl(baseUrl, path3, query) {
+  const trimmed = stripTrailingSlash(baseUrl);
+  const suffix = path3.startsWith("/") ? path3 : `/${path3}`;
+  if (!query)
+    return `${trimmed}${suffix}`;
+  const search = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined)
+      continue;
+    search.append(key, String(value));
+  }
+  const qs = search.toString();
+  return qs ? `${trimmed}${suffix}?${qs}` : `${trimmed}${suffix}`;
+}
+async function readErrorBody(response) {
+  const text = await response.text().catch(() => "");
+  if (!text)
+    return `${response.status} ${response.statusText}`;
+  return `${response.status} ${response.statusText}: ${text.slice(0, 1000)}`;
+}
+async function createAiHttpContext(service, options) {
+  const { status, bearerToken } = await resolveStatus(options);
+  const explicitTenantOverride = options?.tenantName !== undefined;
+  const tenantName = options?.tenantName ?? status.tenantName;
+  const tenantSegment = explicitTenantOverride ? options?.tenantName : status.tenantId ?? status.tenantName;
+  const segments = [
+    status.baseUrl ? stripTrailingSlash(status.baseUrl) : undefined,
+    status.organizationId ? encodeURIComponent(status.organizationId) : undefined
+  ];
+  if (tenantSegment) {
+    segments.push(encodeURIComponent(tenantSegment));
+  }
+  segments.push(SERVICE_PATH[service]);
+  const baseUrl = segments.filter(Boolean).join("/");
+  const baseHeaders = {
+    Authorization: `Bearer ${bearerToken}`,
+    Accept: "application/json"
+  };
+  if (status.organizationId) {
+    baseHeaders["x-uipath-internal-accountid"] = status.organizationId;
+  }
+  if (!explicitTenantOverride && status.tenantId) {
+    baseHeaders["x-uipath-internal-tenantid"] = status.tenantId;
+  }
+  baseHeaders["x-uipath-requestingproduct"] = REQUESTING_PRODUCT;
+  baseHeaders["X-UiPath-LLMGateway-AllowFull4xxResponse"] = "true";
+  const fetchJson = async (req) => {
+    const url = buildUrl(baseUrl, req.path, req.query);
+    const headers = {
+      ...baseHeaders,
+      ...req.extraHeaders ?? {}
+    };
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method: req.method,
+      headers,
+      body: req.body !== undefined ? JSON.stringify(req.body) : undefined
+    });
+    if (!response.ok) {
+      throw new Error(await readErrorBody(response));
+    }
+    if (response.status === 204) {
+      return;
+    }
+    const text = await response.text();
+    if (!text)
+      return;
+    return JSON.parse(text);
+  };
+  const fetchVoid = async (req) => {
+    const url = buildUrl(baseUrl, req.path, req.query);
+    const headers = {
+      ...baseHeaders,
+      ...req.extraHeaders ?? {}
+    };
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method: req.method,
+      headers,
+      body: req.body !== undefined ? JSON.stringify(req.body) : undefined
+    });
+    if (!response.ok) {
+      throw new Error(await readErrorBody(response));
+    }
+  };
+  return {
+    baseUrl,
+    organizationId: status.organizationId,
+    tenantId: explicitTenantOverride ? undefined : status.tenantId,
+    tenantName,
+    requestingProduct: REQUESTING_PRODUCT,
+    fetchJson,
+    fetchVoid
+  };
+}
+async function getDiscoveryModels(options) {
+  const context = await createAiHttpContext("llm-gateway", options);
+  const extraHeaders = {
+    "X-UiPath-LlmGateway-RequestingProduct": options.product,
+    "X-UiPath-LlmGateway-RequestingFeature": options.feature
+  };
+  if (options.operationCode) {
+    extraHeaders["X-UiPath-LlmGateway-OperationCode"] = options.operationCode;
+  }
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options.loginValidity
+  });
+  if (status.accessToken) {
+    try {
+      const claims = parseJWT(status.accessToken);
+      if (typeof claims.sub === "string") {
+        extraHeaders["X-UiPath-LlmGateway-UserId"] = claims.sub;
+      }
+    } catch {}
+  }
+  return context.fetchJson({
+    method: "GET",
+    path: "/api/discovery",
+    extraHeaders
+  });
+}
+var LLM_AS_JUDGE_DISCOVERY = {
+  product: "guardrails",
+  feature: "llm-as-judge-validator",
+  operationCode: "Guardrails.LlmAsJudge.Debug"
+};
+async function getLlmJudgeModelIds(options) {
+  const models = await getDiscoveryModels({
+    ...options,
+    ...LLM_AS_JUDGE_DISCOVERY
+  });
+  return models.filter((m) => !m.isBlockedByPolicy).map((m) => m.modelId);
+}
+
+// src/services/llm-judge-models-service.ts
+var JUDGE_MIDDLEWARE = "UiPathLLMAsJudgeMiddleware";
+async function loadLlmJudgeModels(fs7, projectPath) {
+  const source = await readEntrySource(fs7, projectPath);
+  if (source === undefined || !source.includes(JUDGE_MIDDLEWARE)) {
+    return;
+  }
+  const [err, models] = await catchError(getLlmJudgeModelIds());
+  if (err || models === undefined) {
+    return;
+  }
+  return models;
+}
+async function readEntrySource(fs7, projectPath) {
+  const entryPath = await resolveEntryPyPath2(fs7, projectPath);
+  const [err, raw] = await catchError(fs7.readFile(fs7.path.join(projectPath, entryPath), "utf-8"));
+  return err || raw == null ? undefined : raw;
+}
+async function resolveEntryPyPath2(fs7, projectPath) {
+  const [, raw] = await catchError(fs7.readFile(fs7.path.join(projectPath, "langgraph.json"), "utf-8"));
+  if (raw != null) {
+    const [, parsed] = await catchError(Promise.resolve().then(() => JSON.parse(raw)));
+    const config = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+    const graphs = config?.graphs;
+    if (typeof graphs === "object" && graphs !== null) {
+      for (const spec of Object.values(graphs)) {
+        if (typeof spec === "string") {
+          const filePart = spec.split(":")[0]?.replace(/^\.\//, "").trim();
+          if (filePart?.endsWith(".py")) {
+            return filePart;
+          }
+        }
+      }
+    }
+  }
+  return "main.py";
+}
+
+// src/commands/review.ts
+var CODES = {
+  success: "CodedAgentReview",
+  invalidChecks: "CodedAgentReviewInvalidChecks",
+  failed: "CodedAgentReviewFailed"
+};
+var ZERO_BY_CATEGORY = {
+  evals: 0,
+  schema: 0,
+  tools: 0,
+  guardrails: 0,
+  code: 0,
+  general: 0
+};
+var REVIEW_EXAMPLES = [
+  {
+    Description: "Review a project at a specific path",
+    Command: "uip codedagent review ./my-coded-agent",
+    Output: {
+      Code: CODES.success,
+      Data: {
+        ProjectDir: "./my-coded-agent",
+        Verdict: "PASS",
+        Score: 100,
+        Grade: "A+",
+        Issues: [],
+        Strengths: [],
+        Stats: {
+          errors: 0,
+          warnings: 0,
+          infos: 0,
+          byCategory: { ...ZERO_BY_CATEGORY }
+        }
+      }
+    }
+  },
+  {
+    Description: "Run only the rules in specific categories (comma-separated)",
+    Command: "uip codedagent review --checks code",
+    Output: {
+      Code: CODES.success,
+      Data: {
+        ProjectDir: ".",
+        Verdict: "PASS",
+        Score: 100,
+        Grade: "A+",
+        Issues: [],
+        Strengths: [],
+        Stats: {
+          errors: 0,
+          warnings: 0,
+          infos: 0,
+          byCategory: { ...ZERO_BY_CATEGORY }
+        }
+      }
+    }
+  }
+];
+var registerReviewCommand = (program) => {
+  program.command("review").description("Review a coded agent project against the deterministic rule set. " + "Returns a verdict (PASS/FAIL), score (0-100), grade (A+...F), and a list of issues.").argument("[path]", "Agent project directory", ".").option("--checks <categories>", `Comma-separated rule categories to run (default: all). Known categories: ${listCategories().join(", ")}.`).examples(REVIEW_EXAMPLES).trackedAction(processContext, async (targetPath, options) => {
+    const fs7 = getFileSystem();
+    const projectPath = targetPath;
+    let categories;
+    if (options.checks !== undefined) {
+      const parts = options.checks.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      if (parts.length === 0) {
+        const knownCategories = listCategories().join(", ");
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Code: CODES.invalidChecks,
+          Message: "`--checks` requires at least one category.",
+          Instructions: `Known categories: ${knownCategories}. Omit --checks to run all rules.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      categories = parts;
+    }
+    const llmJudgeModels = await loadLlmJudgeModels(fs7, projectPath);
+    const [err, outcome] = await catchError(reviewCodedAgent(projectPath, { categories, llmJudgeModels }, fs7));
+    if (err) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES.failed,
+        Message: `Review failed: ${extractErrorMessageSync(err)}`,
+        Instructions: "Verify the project path exists and is a readable agent project. " + "Run `uip codedagent review --help` for usage."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!outcome.ok) {
+      const knownCategories = listCategories().join(", ");
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES.invalidChecks,
+        Message: `Unknown category value(s): ${outcome.unknown.join(", ")}.`,
+        Instructions: `Known categories: ${knownCategories}.`
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { result } = outcome;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: CODES.success,
+      Data: {
+        ProjectDir: projectPath,
+        Verdict: result.verdict,
+        Score: result.score,
+        Grade: result.grade,
+        Issues: result.issues,
+        Strengths: result.strengths,
+        Stats: result.stats
+      }
+    });
+  });
+};
+
+// src/telemetry-events.ts
+var CodedAgentsTelemetryEvents = {
+  DefaultAction: "CodedAgents.DefaultAction",
+  Setup: "CodedAgents.Setup",
+  Exec: "CodedAgents.Exec",
+  Help: "CodedAgents.Help"
+};
+
+// src/tool.ts
+var PROJECT_ID_ENV_NAME = "UIPATH_PROJECT_ID";
+var PROJECT_ID_INSTRUCTIONS = [
+  "Create or open a Coded Agent project in Studio Web, copy its project ID, then set it before pushing:",
+  `  echo "${PROJECT_ID_ENV_NAME}=<id>" >> .env`,
+  "  uip codedagent push"
+].join(`
+`);
+var metadata = {
+  name: "codedagent-tool",
+  version: package_default.version,
+  description: "Build, run, deploy, and manage AI Agents.",
+  commandPrefix: "codedagent"
+};
+var { executeCommand } = createExecuteCommand({
+  telemetryEvent: CodedAgentsTelemetryEvents.Exec,
+  commandRules: COMMAND_RULES,
+  commandPreflight: codedAgentCommandPreflight,
+  requiredEnvironmentVariables: [
+    {
+      name: PROJECT_ID_ENV_NAME,
+      commands: ["push"],
+      instructions: PROJECT_ID_INSTRUCTIONS,
+      skipWhenHelp: true
+    }
+  ]
+});
+var registerSetupCommand = createSetupCommand({
+  telemetryEvent: CodedAgentsTelemetryEvents.Setup,
+  successCode: "CodedAgentsSetup"
+});
+function isHelpRequest(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function isCodedAgentShipCommand(name) {
+  return name === "deploy" || name === "publish";
+}
+function hasFlag(args, ...flags) {
+  return args.some((arg) => flags.includes(arg));
+}
+function getCodedAgentShipTarget(name, args) {
+  const suffix = name === "publish" ? "feed" : "deployment";
+  if (hasFlag(args, "--my-workspace", "-w")) {
+    return `personal_workspace_coded_agent_${suffix}`;
+  }
+  if (hasFlag(args, "--tenant")) {
+    return `tenant_coded_agent_${suffix}`;
+  }
+  return `coded_agent_${suffix}`;
+}
+var registerWhitelistedCommand = (program, name, description) => {
+  program.command(name, { hidden: false }).description(description).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).argument("[args...]").trackedAction(processContext, async (args = []) => {
+    const result = await executeCommand(["_", "_", "exec", name, ...args], {});
+    if (result.ok && isCodedAgentShipCommand(name) && !isHelpRequest(args)) {
+      trackShipSucceeded({
+        ship_kind: name,
+        target: getCodedAgentShipTarget(name, args),
+        project_type: "coded_agent",
+        command_name: `uip.codedagent.${name}`,
+        artifact_correlation_key: process.env[PROJECT_ID_ENV_NAME]
+      });
+    }
+  });
+};
+var registerCommands = async (program) => {
+  registerSetupCommand(program);
+  registerReviewCommand(program);
+  for (const { name, description } of WHITELISTED_COMMANDS) {
+    registerWhitelistedCommand(program, name, description);
+  }
+  program.showHelpAfterError(false);
+};
+
+export { metadata, registerCommands };
+
+//# debugId=BD6D1CCB31FE2BEA64756E2164756E21