@uipath/case-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/dist/packager-tool-w3h8xrnv.js

@@ -0,0 +1,472 @@
+import {
+  catchError,
+  logger,
+  unsupportedSolutionProjectType
+} from "./packager-tool-zx48pq4v.js";
+
+// ../solution-sdk/src/solution-file.ts
+var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
+  ProcessOrchestration: "processOrchestration"
+};
+function normalizeProjectType(projectType) {
+  return STUDIO_WEB_PROJECT_TYPE_OVERRIDES[projectType] ?? projectType;
+}
+function toPortableRelativePath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function createSolutionManifest(fs, solutionDir, solutionName, options = {}) {
+  const resolvedDir = fs.path.resolve(solutionDir);
+  if (!(options.allowExistingDir && await fs.exists(resolvedDir))) {
+    await fs.mkdir(resolvedDir);
+  }
+  const solutionId = crypto.randomUUID();
+  const manifest = {
+    DocVersion: "1.0.0",
+    StudioMinVersion: "2025.10.0",
+    SolutionId: solutionId,
+    Projects: []
+  };
+  const solutionFile = fs.path.join(resolvedDir, `${solutionName}.uipx`);
+  await fs.writeFile(solutionFile, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    solutionDir: resolvedDir,
+    solutionFile,
+    solutionId
+  };
+}
+var AUTO_SOLUTION_SUFFIX = "Solution";
+async function autoScaffoldSolution(fs, baseDir, projectName) {
+  const solutionName = `${projectName}${AUTO_SOLUTION_SUFFIX}`;
+  const solutionDir = fs.path.resolve(baseDir, solutionName);
+  const expectedSolutionFile = fs.path.join(solutionDir, `${solutionName}.uipx`);
+  if (await fs.exists(expectedSolutionFile)) {
+    return {
+      Name: solutionName,
+      Path: solutionDir,
+      SolutionFile: expectedSolutionFile
+    };
+  }
+  const { solutionFile } = await createSolutionManifest(fs, solutionDir, solutionName, { allowExistingDir: true });
+  return {
+    Name: solutionName,
+    Path: solutionDir,
+    SolutionFile: solutionFile
+  };
+}
+async function prepareProjectLocation(fs, candidateProjectDir, projectName, options = {}) {
+  const resolved = fs.path.resolve(candidateProjectDir);
+  if (options.skipRegistration) {
+    return { projectDir: resolved };
+  }
+  const discovery = await findNearestParentUipxFile(fs, resolved);
+  if (discovery.status !== "notFound") {
+    return { projectDir: resolved };
+  }
+  const baseDir = fs.path.dirname(resolved);
+  const autoCreatedSolution = await autoScaffoldSolution(fs, baseDir, projectName);
+  const projectDir = fs.path.join(autoCreatedSolution.Path, projectName);
+  await warnIfCandidateDirShadowed(fs, resolved, projectDir);
+  return { projectDir, autoCreatedSolution };
+}
+async function warnIfCandidateDirShadowed(fs, candidateDir, projectDir) {
+  const [, exists] = await catchError(fs.exists(candidateDir));
+  if (!exists) {
+    return;
+  }
+  const [, entries] = await catchError(fs.readdir(candidateDir));
+  if (!entries || entries.length === 0) {
+    return;
+  }
+  logger.warn(`An existing directory "${candidateDir}" was left untouched. ` + `The project was created inside the auto-created solution at "${projectDir}". ` + "Run init from inside an existing solution, or pass --skip-solution-registration, if you meant to use the existing directory.");
+}
+async function updateUipxSolutionId(fs, uipxPath, newSolutionId) {
+  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (readError || !content) {
+    logger.error(`Could not read .uipx file for update: ${readError?.message ?? "empty file"}`);
+    return;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.error(`Could not parse .uipx file for update: ${parseError.message}`);
+    return;
+  }
+  parsed.SolutionId = newSolutionId;
+  const [writeError] = await catchError(fs.writeFile(uipxPath, JSON.stringify(parsed, null, 4)));
+  if (writeError) {
+    logger.error(`Could not update .uipx with new SolutionId: ${writeError.message}`);
+  } else {
+    logger.info(`Updated .uipx with Studio Web SolutionId: ${newSolutionId}`);
+  }
+}
+async function findSolutionFile(fs, projectPath) {
+  const parentDir = fs.path.resolve(projectPath, "..");
+  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  if (dirError) {
+    logger.error(`Could not read parent directory for .uipx file: ${dirError.message}`);
+    return;
+  }
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile) {
+    logger.info("No .uipx solution file found in parent directory.");
+    return;
+  }
+  const uipxPath = fs.path.join(parentDir, uipxFile);
+  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (readError || content === null) {
+    logger.error(`Could not read .uipx file: ${readError?.message ?? "file returned null"}`);
+    return;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.error(`Could not parse .uipx file: ${parseError.message}`);
+    return;
+  }
+  const solutionId = parsed.SolutionId;
+  const projectId = parsed.Projects?.[0]?.Id;
+  if (!solutionId) {
+    logger.info("No SolutionId found in .uipx file.");
+    return;
+  }
+  logger.info(`Found solution file: ${uipxFile} (SolutionId: ${solutionId})`);
+  return {
+    solutionId,
+    projectId: projectId ?? crypto.randomUUID()
+  };
+}
+async function updateSolutionFile(fs, projectPath, newSolutionId) {
+  const parentDir = fs.path.resolve(projectPath, "..");
+  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  if (dirError)
+    return;
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile)
+    return;
+  const uipxPath = fs.path.join(parentDir, uipxFile);
+  await updateUipxSolutionId(fs, uipxPath, newSolutionId);
+}
+async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
+  if (options?.skipRegistration) {
+    return {
+      Status: "OptedOut",
+      Message: "Solution auto-registration skipped (--skip-solution-registration).",
+      Instructions: buildOptedOutInstructions(fs.path.resolve(projectDir))
+    };
+  }
+  const [registrationError, registration] = await catchError(registerProjectInParentSolution(fs, projectDir));
+  if (registrationError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Instructions: buildRegistrationFailureInstructions(projectDir, registrationError.message)
+    };
+  }
+  return registration;
+}
+async function registerProjectInParentSolution(fs, projectDir) {
+  const resolvedProjectDir = fs.path.resolve(projectDir);
+  const discovery = await findNearestParentUipxFile(fs, resolvedProjectDir);
+  if (discovery.status === "notFound") {
+    return {
+      Status: "NotInSolution",
+      Message: "Project created in standalone mode; no parent .uipx solution found.",
+      Instructions: buildStandaloneInstructions(resolvedProjectDir)
+    };
+  }
+  if (discovery.status === "skipped") {
+    return discovery.registration;
+  }
+  const solutionFile = discovery.solutionFile;
+  const solutionDir = fs.path.dirname(solutionFile);
+  const relativeProjectDir = fs.path.relative(solutionDir, resolvedProjectDir);
+  if (relativeProjectDir === "" || relativeProjectDir.startsWith("..") || fs.path.isAbsolute(relativeProjectDir)) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: `Project must reside within the solution folder.
+  Solution: ${solutionDir}
+  Project:  ${resolvedProjectDir}`
+    };
+  }
+  const [projectFileError, projectFile] = await findProjectFile(fs, resolvedProjectDir);
+  if (projectFileError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectFileError.message)
+    };
+  }
+  const [projectManifestError, projectManifest] = await readProjectManifest(fs, projectFile.filePath, projectFile.useProjectJson);
+  if (projectManifestError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectManifestError.message)
+    };
+  }
+  const unsupportedReason = unsupportedSolutionProjectType(projectManifest.projectType);
+  if (unsupportedReason) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: unsupportedReason
+    };
+  }
+  const projectRelativePath = toPortableRelativePath(fs.path.join(relativeProjectDir, projectFile.fileName));
+  const [solutionError, solution] = await readSolutionManifest(fs, solutionFile);
+  if (solutionError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, solutionError.message)
+    };
+  }
+  const existingProject = solution.projects.find((project) => toPortableRelativePath(project.ProjectRelativePath) === projectRelativePath);
+  if (existingProject) {
+    return {
+      Status: "AlreadyRegistered",
+      Message: "Project already registered in solution.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      ProjectId: typeof existingProject.Id === "string" ? existingProject.Id : undefined,
+      Instructions: buildRegistrationSuccessInstructions(solutionDir)
+    };
+  }
+  const projectId = crypto.randomUUID();
+  solution.projects.push({
+    Type: normalizeProjectType(projectManifest.projectType),
+    ProjectRelativePath: projectRelativePath,
+    Id: projectId
+  });
+  solution.content.Projects = solution.projects;
+  const [writeError] = await catchError(fs.writeFile(solutionFile, `${JSON.stringify(solution.content, null, 2)}
+`));
+  if (writeError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, writeError.message)
+    };
+  }
+  return {
+    Status: "Registered",
+    Message: "Project registered in parent solution.",
+    Solution: solutionFile,
+    Project: projectRelativePath,
+    ProjectId: projectId,
+    Instructions: buildRegistrationSuccessInstructions(solutionDir)
+  };
+}
+async function findNearestParentUipxFile(fs, projectDir) {
+  let currentDir = fs.path.dirname(fs.path.resolve(projectDir));
+  while (true) {
+    const [readDirError, entries] = await catchError(fs.readdir(currentDir));
+    if (readDirError) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Failed",
+          Message: "Project registration failed.",
+          Instructions: buildRegistrationFailureInstructions(projectDir, `Could not inspect parent directory for a solution: ${currentDir}
+${readDirError.message}`)
+        }
+      };
+    }
+    const solutionFiles = entries.filter((entry) => entry.endsWith(".uipx"));
+    if (solutionFiles.length > 1) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Skipped",
+          Message: "Project registration skipped.",
+          Instructions: `Found multiple .uipx files in ${currentDir}: ${solutionFiles.join(", ")}. Run 'uip solution projects add "${projectDir}" <solution.uipx>' to choose one.`
+        }
+      };
+    }
+    if (solutionFiles.length === 1) {
+      return {
+        status: "found",
+        solutionFile: fs.path.join(currentDir, solutionFiles[0])
+      };
+    }
+    const parentDir = fs.path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return { status: "notFound" };
+    }
+    currentDir = parentDir;
+  }
+}
+async function findProjectFile(fs, projectDir) {
+  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
+  if (await fs.exists(uiprojPath)) {
+    return [
+      null,
+      {
+        filePath: uiprojPath,
+        fileName: "project.uiproj",
+        useProjectJson: false
+      }
+    ];
+  }
+  const jsonProjectPath = fs.path.join(projectDir, "project.json");
+  if (await fs.exists(jsonProjectPath)) {
+    return [
+      null,
+      {
+        filePath: jsonProjectPath,
+        fileName: "project.json",
+        useProjectJson: true
+      }
+    ];
+  }
+  return [
+    new Error(`No project file found in ${projectDir}. Expected project.uiproj or project.json.`),
+    null
+  ];
+}
+async function readProjectManifest(fs, filePath, useProjectJson) {
+  const [readError, rawContent] = await catchError(fs.readFile(filePath, "utf-8"));
+  if (readError || !rawContent) {
+    return [readError ?? new Error(`Unable to read ${filePath}.`), null];
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in project file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [new Error(`Invalid project file: ${filePath}`), null];
+  }
+  const designOptions = parsed.designOptions;
+  const outputType = useProjectJson && isRecord(designOptions) ? readString(designOptions.outputType) : undefined;
+  const projectType = outputType ?? readString(parsed.ProjectType);
+  if (!projectType) {
+    return [new Error(`ProjectType not found in ${filePath}`), null];
+  }
+  return [
+    null,
+    {
+      projectType
+    }
+  ];
+}
+async function readSolutionManifest(fs, solutionFile) {
+  const [readError, rawContent] = await catchError(fs.readFile(solutionFile, "utf-8"));
+  if (readError || !rawContent) {
+    return [
+      readError ?? new Error(`Unable to read solution file: ${solutionFile}`),
+      null
+    ];
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in solution file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a JSON object.`),
+      null
+    ];
+  }
+  if (!Array.isArray(parsed.Projects)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a Projects array.`),
+      null
+    ];
+  }
+  const projects = [];
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] must be an object.`),
+        null
+      ];
+    }
+    const projectRelativePath = readString(project.ProjectRelativePath);
+    if (!projectRelativePath) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] is missing ProjectRelativePath. Use 'uip solution projects add' to repair the manifest.`),
+        null
+      ];
+    }
+    projects.push({
+      ...project,
+      Type: readString(project.Type) ?? "",
+      ProjectRelativePath: projectRelativePath,
+      Id: readString(project.Id) ?? ""
+    });
+  }
+  return [null, { content: parsed, projects }];
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+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}"'.`
+  ].join(`
+`);
+}
+function buildRegistrationFailureInstructions(projectDir, details) {
+  return [
+    "Automatic solution registration could not complete.",
+    `Run 'uip solution projects add "${projectDir}" <solution.uipx>' after checking the project and solution files.`,
+    `Details: ${details}`
+  ].join(`
+`);
+}
+function buildStandaloneInstructions(projectDir) {
+  return [
+    "No parent solution was found by walking ancestor directories.",
+    "Studio Web upload, `flow debug`, and packaging require an enclosing solution.",
+    `To link this project to a solution, run 'uip solution init "<SolutionName>"' then 'uip solution projects add "${projectDir}" <SolutionName>.uipx'.`
+  ].join(`
+`);
+}
+function buildOptedOutInstructions(projectDir) {
+  return [
+    "Automatic solution registration was skipped because --skip-solution-registration was passed.",
+    `To register this project later, run 'uip solution projects add "${projectDir}" <SolutionName>.uipx' from within the solution.`
+  ].join(`
+`);
+}
+async function findSolutionFileUpward(fs, startDir) {
+  let dir = startDir;
+  while (true) {
+    const entries = await fs.readdir(dir);
+    const files = entries.filter((f) => f.endsWith(".uipx"));
+    if (files.length === 1) {
+      return fs.path.join(dir, files[0]);
+    }
+    if (files.length > 1) {
+      throw new Error(`Multiple .uipx files found in ${dir}. Please specify which solution file to use.`);
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      throw new Error(`No .uipx solution file found (searched from ${startDir} to filesystem root)`);
+    }
+    dir = parent;
+  }
+}
+
+export { normalizeProjectType, prepareProjectLocation, findSolutionFile, updateSolutionFile, tryRegisterProjectInParentSolution, findSolutionFileUpward };
+
+//# debugId=9CAB90AF72A692D764756E2164756E21

package/dist/packager-tool-we1phz71.js

@@ -0,0 +1,41 @@
+import {
+  catchError
+} from "./packager-tool-zx48pq4v.js";
+import {
+  getFileSystem
+} from "./packager-tool-1cb0d5e0.js";
+
+// ../maestro-sdk/src/registry/snapshot.ts
+function maestroRegistryRoot(filesystem) {
+  const fs = filesystem ?? getFileSystem();
+  return fs.env.getenv("UIP_MAESTRO_REGISTRY_HOME") ?? fs.path.join(fs.env.homedir(), ".uipath", "maestro", "registry");
+}
+function maestroRegistryCurrentPath(filesystem) {
+  const fs = filesystem ?? getFileSystem();
+  return fs.path.join(maestroRegistryRoot(fs), "current.json");
+}
+async function resolveMaestroRegistry(filesystem) {
+  const fs = filesystem ?? getFileSystem();
+  const [readError, content] = await catchError(fs.readFile(maestroRegistryCurrentPath(fs), "utf-8"));
+  if (readError || content === null)
+    return null;
+  const [parseError, current] = catchError(() => JSON.parse(content));
+  if (parseError || !current)
+    return null;
+  const snapshotPath = current.snapshotPath;
+  if (typeof snapshotPath !== "string" || snapshotPath.length === 0) {
+    return null;
+  }
+  return {
+    libraryHash: typeof current.libraryHash === "string" ? current.libraryHash : "",
+    snapshotPath,
+    libraryJson: fs.path.join(snapshotPath, "library-json"),
+    libraryMarkdown: fs.path.join(snapshotPath, "library-md"),
+    connectors: fs.path.join(snapshotPath, "connectors"),
+    updatedAt: typeof current.updatedAt === "string" ? current.updatedAt : ""
+  };
+}
+
+export { resolveMaestroRegistry };
+
+//# debugId=4F930E85411BFAC964756E2164756E21