@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-0z498fh0.js

@@ -0,0 +1,331 @@
+import {
+  getAgentProjectMetadataReader
+} from "./packager-tool-8qp60s20.js";
+import {
+  extractIOFromEntryPoints,
+  getServiceType,
+  taskDefinitionsToNodeManifests,
+  withErrorHandles
+} from "./packager-tool-9c2hte0h.js";
+import {
+  logger,
+  quoteForShell
+} from "./packager-tool-zgm0r4yp.js";
+import {
+  getFileSystem
+} from "./packager-tool-hdxtgckw.js";
+import {
+  catchError
+} from "./packager-tool-wv85dhy2.js";
+
+// ../maestro-sdk/src/registry/solution-discovery.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var EMPTY_IO = {
+  inputs: {},
+  outputs: {}
+};
+function findEnclosingProjectId(solutionDir, projects, cwd) {
+  const fs = getFileSystem();
+  for (const p of projects) {
+    const projDir = fs.path.resolve(solutionDir, fs.path.dirname(p.ProjectRelativePath));
+    if (cwd === projDir)
+      return p.Id;
+    const rel = fs.path.relative(projDir, cwd);
+    if (rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel)) {
+      return p.Id;
+    }
+  }
+  return;
+}
+function solutionSearchDirs() {
+  const fs = getFileSystem();
+  const cwd = fs.env.cwd();
+  return [cwd, fs.path.resolve(cwd, ".."), fs.path.resolve(cwd, "../..")];
+}
+async function readSolutionAt(dir) {
+  const fs = getFileSystem();
+  const [readErr, entries] = await catchError(fs.readdir(dir));
+  if (readErr)
+    return null;
+  const uipxName = entries.find((e) => e.endsWith(".uipx"));
+  if (!uipxName)
+    return null;
+  const uipxPath = fs.path.join(dir, uipxName);
+  const [fileErr, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (fileErr || !content)
+    return null;
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !parsed.SolutionId)
+    return null;
+  return {
+    solutionId: parsed.SolutionId,
+    solutionDir: dir,
+    projects: parsed.Projects ?? []
+  };
+}
+async function findSolutionFromCwd() {
+  const cwd = getFileSystem().env.cwd();
+  for (const dir of solutionSearchDirs()) {
+    const solution = await readSolutionAt(dir);
+    if (solution === null)
+      continue;
+    return {
+      ...solution,
+      currentProjectId: findEnclosingProjectId(dir, solution.projects, cwd)
+    };
+  }
+  return null;
+}
+async function resolveProjectEntryPointIO(projectDir) {
+  const fs = getFileSystem();
+  const fromSource = await readEntryPointsFile(fs.path.join(projectDir, "entry-points.json"), fs.path.join(projectDir, "content", "entry-points.json"));
+  if (fromSource.io)
+    return { io: fromSource.io, contract: "known" };
+  const fromFlow = await readProjectIOFromFlowVariables(projectDir);
+  if (fromFlow.io)
+    return { io: fromFlow.io, contract: "known" };
+  const fromBuild = await readEntryPointsFile(fs.path.join(projectDir, ".local", "content", "entry-points.json"));
+  if (fromBuild.io)
+    return { io: fromBuild.io, contract: "known" };
+  const states = [fromSource.state, fromFlow.state, fromBuild.state];
+  const contract = states.includes("valid") ? "known" : states.includes("invalid") ? "unreadable" : "missing";
+  return { io: EMPTY_IO, contract };
+}
+async function readEntryPointsFile(...candidates) {
+  const fs = getFileSystem();
+  let state = "absent";
+  for (const filePath of candidates) {
+    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    if (err || content === null)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const entryPoints = parsed?.entryPoints;
+    if (parseErr || !Array.isArray(entryPoints) || entryPoints.length > 0 && !isRecord(entryPoints[0])) {
+      if (state === "absent")
+        state = "invalid";
+      continue;
+    }
+    state = "valid";
+    if (entryPoints.length === 0)
+      continue;
+    return { io: extractIOFromEntryPoints({ entryPoints }), state };
+  }
+  return { state };
+}
+async function readProjectIOFromFlowVariables(projectDir) {
+  const fs = getFileSystem();
+  const [readErr, entries] = await catchError(fs.readdir(projectDir));
+  if (readErr || !Array.isArray(entries))
+    return { state: "absent" };
+  const flowFileName = entries.find((entry) => entry.endsWith(".flow"));
+  if (!flowFileName)
+    return { state: "absent" };
+  const flowPath = fs.path.join(projectDir, flowFileName);
+  const [readFileErr, content] = await catchError(fs.readFile(flowPath, "utf-8"));
+  if (readFileErr || !content)
+    return { state: "invalid" };
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !isRecord(parsed))
+    return { state: "invalid" };
+  const variables = parsed.variables;
+  if (variables !== undefined && !isRecord(variables))
+    return { state: "invalid" };
+  const globals = variables?.globals;
+  if (globals !== undefined && (!Array.isArray(globals) || !globals.every(isRecord)))
+    return { state: "invalid" };
+  if (!globals || globals.length === 0)
+    return { state: "valid" };
+  const inputProps = {};
+  const outputProps = {};
+  for (const variable of globals) {
+    if (!variable.id || !variable.direction)
+      continue;
+    const schema = {
+      type: variable.type ?? "string"
+    };
+    if (variable.description) {
+      schema.description = variable.description;
+    }
+    if (variable.direction === "in" || variable.direction === "inout") {
+      inputProps[variable.id] = schema;
+    }
+    if (variable.direction === "out" || variable.direction === "inout") {
+      outputProps[variable.id] = schema;
+    }
+  }
+  const hasInputs = Object.keys(inputProps).length > 0;
+  const hasOutputs = Object.keys(outputProps).length > 0;
+  if (!hasInputs && !hasOutputs)
+    return { state: "valid" };
+  const synthetic = {
+    entryPoints: [
+      {
+        filePath: flowFileName,
+        input: hasInputs ? { type: "object", properties: inputProps } : undefined,
+        output: hasOutputs ? { type: "object", properties: outputProps } : undefined
+      }
+    ]
+  };
+  return { io: extractIOFromEntryPoints(synthetic), state: "valid" };
+}
+async function readProjectName(projectDir) {
+  const fs = getFileSystem();
+  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
+  const [err, content] = await catchError(fs.readFile(uiprojPath, "utf-8"));
+  if (!err && content) {
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (!parseErr && isRecord(parsed) && typeof parsed.Name === "string" && parsed.Name.length > 0) {
+      return parsed.Name;
+    }
+  }
+  return fs.path.basename(projectDir);
+}
+async function loadResourceKeyMap(solutionDir) {
+  const fs = getFileSystem();
+  const map = new Map;
+  const processDir = fs.path.join(solutionDir, "resources", "solution_folder", "process");
+  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  if (dirErr)
+    return map;
+  for (const typeDir of typeDirs) {
+    const typePath = fs.path.join(processDir, typeDir);
+    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    if (filesErr)
+      continue;
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      const filePath = fs.path.join(typePath, file);
+      const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+      if (readErr || !content)
+        continue;
+      const [parseErr, parsed] = catchError(() => JSON.parse(content));
+      if (parseErr || !isRecord(parsed))
+        continue;
+      const resource = parsed.resource;
+      if (!isRecord(resource))
+        continue;
+      const projectKey = resource.projectKey;
+      const resourceKey = resource.key;
+      if (typeof projectKey === "string" && projectKey.length > 0 && typeof resourceKey === "string" && resourceKey.length > 0) {
+        map.set(projectKey.toLowerCase(), resourceKey);
+      }
+    }
+  }
+  return map;
+}
+function invokableSiblings(ctx) {
+  const fs = getFileSystem();
+  const currentId = ctx.currentProjectId?.toLowerCase();
+  return ctx.projects.flatMap((project) => {
+    const serviceType = getServiceType(project.Type);
+    if (!serviceType)
+      return [];
+    if (typeof project.Id !== "string")
+      return [];
+    if (project.Id.toLowerCase() === currentId)
+      return [];
+    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath));
+    return [{ project, serviceType, projectDir }];
+  });
+}
+async function buildInSolutionNodes(ctx) {
+  const manifests = [];
+  const unknownContracts = [];
+  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  for (const { project, serviceType, projectDir } of invokableSiblings(ctx)) {
+    const resourceKey = resourceKeyMap.get(project.Id.toLowerCase());
+    if (!resourceKey)
+      continue;
+    const reader = getAgentProjectMetadataReader();
+    const [name, { io, contract }, projectMetadata] = await Promise.all([
+      readProjectName(projectDir),
+      resolveProjectEntryPointIO(projectDir),
+      reader ? reader(projectDir, project.Type).catch((err) => {
+        logger.debug(`Agent metadata reader failed for ${projectDir}: ${String(err)}`);
+        return {};
+      }) : Promise.resolve({})
+    ]);
+    const task = {
+      name,
+      type: serviceType,
+      resourceKey,
+      inputs: io.inputs,
+      outputs: io.outputs,
+      metadata: {
+        ...projectMetadata,
+        description: `(In-solution) ${name}`,
+        key: resourceKey,
+        name,
+        tags: ["in-solution", "local"],
+        projectId: project.Id,
+        entryPointUniqueId: io.entryPointUniqueId,
+        inputProperties: io.inputProperties
+      }
+    };
+    const nodes = taskDefinitionsToNodeManifests({ [resourceKey]: task }, project.Type);
+    manifests.push(...nodes);
+    if (contract !== "known") {
+      unknownContracts.push({
+        name,
+        type: project.Type,
+        projectDir,
+        nodeTypes: nodes.map((n) => n.nodeType).filter((t) => typeof t === "string"),
+        contract
+      });
+    }
+  }
+  return { manifests: withErrorHandles(manifests), unknownContracts };
+}
+function unknownContractWarning(projects) {
+  if (projects.length === 0)
+    return;
+  const describe = (p) => `'${p.name}' (${p.type}, ${p.projectDir}): ${p.contract === "missing" ? "no entry-points.json yet" : "its entry-points.json or .flow file could not be read"}`;
+  const one = projects.length === 1;
+  const steps = [];
+  if (projects.some((p) => p.contract === "missing"))
+    steps.push("build the project so it writes entry-points.json");
+  if (projects.some((p) => p.contract === "unreadable"))
+    steps.push("fix the file that could not be read");
+  const next = steps.join(", and ");
+  return `No usable argument contract for ${projects.map(describe).join("; ")}. ` + `${one ? "Its node shows" : "Their nodes show"} no inputs or outputs; the arguments are unknown, not empty. ` + `${next[0].toUpperCase()}${next.slice(1)}, then run this command again.`;
+}
+async function findProjectsWithoutProcessResource(ctx) {
+  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  return Promise.all(invokableSiblings(ctx).filter(({ project }) => !resourceKeyMap.has(project.Id.toLowerCase())).map(async ({ project, projectDir }) => ({
+    id: project.Id,
+    name: await readProjectName(projectDir),
+    type: project.Type
+  })));
+}
+function describeProjectsWithoutProcessResource(projects, solutionDir) {
+  if (projects.length === 0)
+    return {};
+  const names = projects.map((p) => `${p.name} (${p.type})`).join(", ");
+  return {
+    Warning: projects.length === 1 ? `Left out 1 project that has no process resource yet: ${names}.` : `Left out ${projects.length} projects that have no process resource yet: ${names}.`,
+    Instructions: `Create the missing process resources, then list the in-solution nodes again to get their node types. Run: ${resourcesRefreshCommand(solutionDir)}`
+  };
+}
+async function explainNodeTypeWithoutProcessResource(nodeType) {
+  const ctx = await findSolutionFromCwd();
+  if (!ctx)
+    return;
+  const lowerNodeType = nodeType.toLowerCase();
+  const project = (await findProjectsWithoutProcessResource(ctx)).find((p) => lowerNodeType.endsWith(`.${p.id.toLowerCase()}`));
+  if (!project)
+    return;
+  return {
+    message: `Project '${project.name}' has no process resource yet, so it has no node type.`,
+    instructions: `Create its process resource, then list the in-solution nodes to get its node type. Run: ${resourcesRefreshCommand(ctx.solutionDir)}`
+  };
+}
+function resourcesRefreshCommand(solutionDir) {
+  return `uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`;
+}
+
+export { solutionSearchDirs, readSolutionAt, findSolutionFromCwd, resolveProjectEntryPointIO, loadResourceKeyMap, buildInSolutionNodes, unknownContractWarning, findProjectsWithoutProcessResource, describeProjectsWithoutProcessResource, explainNodeTypeWithoutProcessResource, resourcesRefreshCommand };
+
+//# debugId=CE02FAA8D35EDFDC64756E2164756E21

package/dist/{packager-tool-j6q8v3kc.js → packager-tool-1q0ee9ht.js}

@@ -1,10 +1,11 @@
 import {
   logger,
+  quoteForShell,
   unsupportedSolutionProjectType
-} from "./packager-tool-yv10w46z.js";
+} from "./packager-tool-zgm0r4yp.js";
 import {
   catchError
-} from "./packager-tool-z1qbc0qf.js";
+} from "./packager-tool-wv85dhy2.js";
 
 // ../solution-sdk/src/solution-file.ts
 var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
@@ -468,7 +469,7 @@ function buildRegistrationSuccessInstructions(solutionDir) {
   return [
     "The project is listed in the parent solution manifest.",
     "Packing or uploading the solution will sync solution resources automatically.",
-    `To sync resources before packaging, run 'uip solution resources refresh --solution-folder "${solutionDir}"'.`
+    `To sync resources before packaging, run: uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`
   ].join(`
 `);
 }
@@ -539,4 +540,4 @@ async function findSolutionFileUpward(fs, startDir) {
 
 export { normalizeProjectType, toPortableRelativePath, readUipxFile, createSolutionManifest, autoScaffoldSolution, prepareProjectLocation, resolveSolutionDir, updateUipxSolutionId, findSolutionFile, updateSolutionFile, tryRegisterProjectInParentSolution, findNearestParentUipxFile, readSolutionManifest, isProjectRegisteredInSolution, findSolutionFileUpward };
 
-//# debugId=AE347857CECB98B364756E2164756E21
+//# debugId=B912693656C764E064756E2164756E21

package/dist/packager-tool-20592jhn.js

@@ -0,0 +1,74 @@
+import {
+  norm
+} from "./packager-tool-jexxh6qf.js";
+
+// ../case-tool/src/services/sdd-convert/ids.ts
+var buildElementId = (stageId, taskId) => `${stageId}-${taskId}`;
+var SLUG_SUFFIX = /^(.*?)\s*\(\s*([^()]+?)\s*\)\s*$/;
+var stageSpellings = (text, position) => {
+  const plain = text.replaceAll("`", "").trim();
+  const names = [plain];
+  const found = SLUG_SUFFIX.exec(plain);
+  const bare = found?.[1].trim() ?? "";
+  const slug = found?.[2].trim() ?? "";
+  if (bare !== "" && bare !== plain)
+    names.push(bare);
+  return {
+    names,
+    ...slug !== "" && { slug },
+    ordinal: `stage ${position}`
+  };
+};
+var referenceSpellings = (text) => {
+  const { names, slug } = stageSpellings(text, 0);
+  return slug === undefined ? names : [...names, slug];
+};
+var indexKey = (name) => name.replaceAll("`", "").trim().toLowerCase();
+var modelKey = (name) => norm(name);
+var everySpelling = (name, position) => {
+  const { names, slug, ordinal } = stageSpellings(name, position);
+  return [...names, ...slug === undefined ? [] : [slug], ordinal].map(indexKey);
+};
+var claim = (index, key, id) => {
+  if (!index.has(key))
+    index.set(key, id);
+};
+var dedupedId = (base, taken) => {
+  let id = base;
+  let suffix = 2;
+  while (taken.has(id)) {
+    id = `${base}${suffix}`;
+    suffix += 1;
+  }
+  taken.add(id);
+  return id;
+};
+var exactKey = (name) => name.replaceAll("`", "").trim();
+var claimOutput = (index, key, task, id) => {
+  const byTask = index.get(key) ?? new Map;
+  index.set(key, byTask);
+  if (!byTask.has(exactKey(task)))
+    byTask.set(exactKey(task), id);
+};
+var lookupOutput = (index, key, task) => {
+  const byTask = index.get(key);
+  if (byTask === undefined)
+    return;
+  const tasksNamed = (name, claim2) => typeof claim2 === "number" ? Array.from({ length: claim2 }, () => name) : [name];
+  const exact = byTask.get(exactKey(task));
+  if (exact !== undefined) {
+    return typeof exact === "number" ? { names: tasksNamed(exactKey(task), exact) } : { id: exact };
+  }
+  const [onlyName, only] = [...byTask.entries()][0] ?? [];
+  if (byTask.size === 1 && onlyName !== undefined && typeof only === "string") {
+    return { id: only };
+  }
+  return {
+    names: [...byTask].flatMap(([name, claim2]) => tasksNamed(name, claim2))
+  };
+};
+var scopedSlaKey = (scope, title) => `${scope}\x00${title}`;
+
+export { buildElementId, stageSpellings, referenceSpellings, indexKey, modelKey, everySpelling, claim, dedupedId, exactKey, claimOutput, lookupOutput, scopedSlaKey };
+
+//# debugId=992FF005D815815B64756E2164756E21