@uipath/solutionpackager-tool-core 1.196.0 → 1.197.0-preview.64

package/dist/index.js

@@ -93,7 +93,7 @@ class TemporaryStorageService {
       } catch {
         return;
       }
-      const pathToCleanup = this._tempFolderPath;
+      const _pathToCleanup = this._tempFolderPath;
       await this.fileSystem.rm(this._tempFolderPath);
       this._tempFolderPath = null;
     } catch {}
@@ -1156,6 +1156,141 @@ class ToolResult {
 function createDefaultBindingsVersion() {
   return { major: 2, minor: 0 };
 }
+// src/services/project-id.ts
+var OPERATE_FILE = "operate.json";
+var PROJECT_FILE = "project.json";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+async function readJsonObject(fs, filePath) {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  if (content === null) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed === null || typeof parsed !== "object") {
+      return;
+    }
+    return parsed;
+  } catch {
+    return;
+  }
+}
+async function writeJsonObject(fs, filePath, data) {
+  await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+async function ensureProjectId(projectPath, fs) {
+  const operatePath = Path.join(projectPath, OPERATE_FILE);
+  const operateExists = await fs.exists(operatePath);
+  if (operateExists) {
+    const operate = await readJsonObject(fs, operatePath);
+    if (operate && isNonEmptyString(operate.projectId)) {
+      return operate.projectId;
+    }
+    if (operate) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, operatePath, {
+        ...operate,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  const projectFilePath = Path.join(projectPath, PROJECT_FILE);
+  const projectFileExists = await fs.exists(projectFilePath);
+  if (projectFileExists) {
+    const projectFile = await readJsonObject(fs, projectFilePath);
+    if (projectFile && isNonEmptyString(projectFile.projectId)) {
+      return projectFile.projectId;
+    }
+    if (projectFile) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, projectFilePath, {
+        ...projectFile,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  return crypto.randomUUID();
+}
+async function ensureProjectIdInOperateFile(operateFilePath, fallbackProjectId, fs) {
+  if (!await fs.exists(operateFilePath)) {
+    return;
+  }
+  const parsed = await readJsonObject(fs, operateFilePath);
+  if (!parsed) {
+    return;
+  }
+  if (isNonEmptyString(parsed.projectId)) {
+    return;
+  }
+  await writeJsonObject(fs, operateFilePath, {
+    ...parsed,
+    projectId: fallbackProjectId
+  });
+}
+async function writeOrBackfillOperateProjectId(operateFilePath, projectId, fs, createIfMissing) {
+  if (await fs.exists(operateFilePath)) {
+    await ensureProjectIdInOperateFile(operateFilePath, projectId, fs);
+    return;
+  }
+  await createIfMissing();
+}
+
+// src/services/content-operate-file.ts
+var OPERATE_SCHEMA = "https://cloud.uipath.com/draft/2024-12/operate";
+async function resolveEntryPointMain(fs, sourceFolder) {
+  const entryPointsFilePath = Path.join(sourceFolder, NugetConstants.EntryPointsFileName);
+  if (!await fs.exists(entryPointsFilePath)) {
+    return "";
+  }
+  const content = await fs.readFile(entryPointsFilePath);
+  if (!content) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(content));
+    return parsed.entryPoints?.[0]?.filePath ?? "";
+  } catch {
+    return "";
+  }
+}
+async function writeContentOperateFile(fs, params) {
+  const operateFilePath = Path.join(params.contentFolder, NugetConstants.OperateFileName);
+  await writeOrBackfillOperateProjectId(operateFilePath, params.projectId, fs, async () => {
+    const main = await resolveEntryPointMain(fs, params.contentFolder);
+    const operateFileModel = {
+      $schema: OPERATE_SCHEMA,
+      contentType: params.contentType,
+      projectId: params.projectId,
+      main,
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    };
+    await fs.writeFile(operateFilePath, JSON.stringify(operateFileModel, null, 2));
+  });
+}
+async function ensureContentOperateFile(fs, params) {
+  const projectId = params.projectStorageId ?? await ensureProjectId(params.projectPath, fs);
+  await writeContentOperateFile(fs, {
+    contentFolder: params.contentFolder,
+    projectId,
+    contentType: params.contentType
+  });
+}
 // src/services/nuget-packager.ts
 import { zipSync as zipSync2 } from "fflate";
 function escapeXml(str) {
@@ -1388,9 +1523,14 @@ if (!_global[REGISTRY_KEY]) {
 }
 var toolsFactoryRepository = _global[REGISTRY_KEY];
 export {
+  writeOrBackfillOperateProjectId,
+  writeContentOperateFile,
   translate,
   toolsFactoryRepository,
   toRelativeUrl,
+  ensureProjectIdInOperateFile,
+  ensureProjectId,
+  ensureContentOperateFile,
   createDefaultBindingsVersion,
   ZipService,
   TranslationService,
@@ -1410,3 +1550,5 @@ export {
   I18nManager,
   BuildConfiguration
 };
+
+//# debugId=E5FDBA39F2E268FE64756E2164756E21

package/dist/services/index.d.ts

@@ -1,5 +1,8 @@
+export type { BuildContentOperateFileParams, ContentOperateFileParams, } from "./content-operate-file.js";
+export { ensureContentOperateFile, writeContentOperateFile, } from "./content-operate-file.js";
 export type { INugetPackager, NugetPackagerResult } from "./nuget-packager.js";
 export { NugetPackager } from "./nuget-packager.js";
+export { ensureProjectId, ensureProjectIdInOperateFile, writeOrBackfillOperateProjectId, } from "./project-id.js";
 export type { ProjectOperationContext } from "./project-operation-context.js";
 export { ProjectTool } from "./project-tool.js";
 export type { IProjectToolFactory } from "./project-tool-factory.js";

package/package.json

@@ -1,40 +1,31 @@
 {
-    "name": "@uipath/solutionpackager-tool-core",
-    "version": "1.196.0",
-    "description": "UiPath contracts for solution packager tools",
-    "type": "module",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        }
-    },
-    "types": "./dist/index.d.ts",
-    "files": [
-        "dist",
-        "!dist/**/*.map"
-    ],
-    "author": "",
-    "license": "ISC",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/UiPath/cli.git",
-        "directory": "packages/packager/packager-core"
-    },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
-    },
-    "devDependencies": {
-        "@types/node": "^25.5.2",
-        "@vitest/browser": "^4.1.6",
-        "@vitest/browser-playwright": "^4.1.6",
-        "@vitest/coverage-v8": "^4.1.6",
-        "typescript": "^6.0.2",
-        "vitest": "^4.1.6"
-    },
-    "dependencies": {
-        "@uipath/filesystem": "1.196.0",
-        "fflate": "^0.8.2"
-    },
-    "gitHead": "bed2b46f1ec33a47a7dcae2e6d4b7ab99bd06981"
+  "name": "@uipath/solutionpackager-tool-core",
+  "version": "1.197.0-preview.64",
+  "description": "UiPath contracts for solution packager tools",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/cli.git",
+    "directory": "packages/packager/packager-core"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@uipath/filesystem": "1.197.0",
+    "fflate": "^0.8.2"
+  },
+  "gitHead": "3977b977945bf519336258da69fd271433eaaef4"
 }