@uipath/solutionpackager-tool-core 0.0.33 → 1.196.0

package/dist/index.js

@@ -108,8 +108,9 @@ class ZipService {
   }
   async extractAsync(zipData, targetPath) {
     const normalizedTarget = targetPath.replace(/\/$/, "");
-    await this.fileSystem.mkdir(normalizedTarget);
     const files = unzipSync(zipData);
+    const dirsToCreate = new Set([normalizedTarget]);
+    const filesToWrite = [];
     const extractedPaths = [];
     for (const [relativePath, data] of Object.entries(files)) {
       if (relativePath.endsWith("/") || data.length === 0) {
@@ -117,7 +118,7 @@ class ZipService {
         if (!dirPath.startsWith(`${normalizedTarget}/`)) {
           throw new Error(`Zip-slip detected: entry "${relativePath}" escapes extraction directory`);
         }
-        await this.fileSystem.mkdir(dirPath);
+        dirsToCreate.add(dirPath);
         continue;
       }
       const fullPath = `${normalizedTarget}/${relativePath}`;
@@ -126,21 +127,26 @@ class ZipService {
       }
       const parentDir = fullPath.split("/").slice(0, -1).join("/");
       if (parentDir) {
-        await this.fileSystem.mkdir(parentDir);
+        dirsToCreate.add(parentDir);
       }
-      await this.fileSystem.writeFile(fullPath, data);
+      filesToWrite.push({ path: fullPath, data });
       extractedPaths.push(fullPath);
     }
+    await Promise.all(Array.from(dirsToCreate, (dir) => this.fileSystem.mkdir(dir)));
+    await Promise.all(filesToWrite.map(({ path, data }) => this.fileSystem.writeFile(path, data)));
     return extractedPaths;
   }
   async compressAsync(sourcePath) {
     const normalizedSource = sourcePath.replace(/\/$/, "");
     const entries = await Path.walkDirectory(this.fileSystem, normalizedSource);
+    const fileContents = await Promise.all(entries.map(async (entry) => ({
+      relativePath: entry.relativePath,
+      data: await this.fileSystem.readFile(entry.absolutePath)
+    })));
     const zippable = {};
-    for (const entry of entries) {
-      const fileData = await this.fileSystem.readFile(entry.absolutePath);
-      if (fileData) {
-        zippable[entry.relativePath] = fileData;
+    for (const { relativePath, data } of fileContents) {
+      if (data) {
+        zippable[relativePath] = data;
       }
     }
     const zipData = zipSync(zippable, {
@@ -1011,9 +1017,9 @@ class LogMessage {
   line;
   id;
   timestamp;
-  constructor(message, logLevel, options) {
+  constructor(message, logLevel, options, timestamp) {
     this.message = message;
-    this.logLevel = logLevel;
+    this.logLevel = LogMessage.toLogLevel(logLevel);
     this.source = options?.source;
     this.sourceTarget = options?.sourceTarget;
     this.progress = options?.progress;
@@ -1021,7 +1027,37 @@ class LogMessage {
     this.filePath = options?.filePath;
     this.line = options?.line;
     this.id = options?.id;
-    this.timestamp = new Date;
+    this.timestamp = LogMessage.resolveTimestamp(timestamp);
+  }
+  static resolveTimestamp(timestamp) {
+    if (timestamp instanceof Date) {
+      return timestamp;
+    }
+    if (timestamp === undefined || timestamp === null) {
+      return new Date;
+    }
+    const parsed = new Date(timestamp);
+    if (Number.isNaN(parsed.getTime())) {
+      console.error(`[LogMessage] invalid timestamp "${timestamp}", defaulting to now`);
+      return new Date;
+    }
+    return parsed;
+  }
+  static toLogLevel(level) {
+    switch (level) {
+      case "Verbose":
+      case "Trace":
+      case "Debug":
+        return "Debug" /* Debug */;
+      case "Warn":
+      case "Warning":
+        return "Warning" /* Warn */;
+      case "Error":
+      case "Critical":
+        return "Error" /* Error */;
+      default:
+        return "Information" /* Info */;
+    }
   }
   toFormattedString() {
     const parts = [];
@@ -1100,6 +1136,7 @@ class ToolResult {
   errorCode;
   message;
   packages;
+  details;
   constructor(errorCode, message, packages = []) {
     this.errorCode = errorCode;
     this.message = message;
@@ -1243,6 +1280,7 @@ class NugetPackager {
 class ProjectTool {
   fileSystem;
   logger;
+  static ProjectFileName = "project.uiproj";
   constructor(fileSystem, logger) {
     this.fileSystem = fileSystem;
     this.logger = logger;
@@ -1263,6 +1301,18 @@ class ProjectTool {
     this.logger.info("Pack operation is a noop");
     return ToolResult.success();
   }
+  async getUiProjectAsync(projectPath) {
+    const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    if (!await this.fileSystem.exists(filePath)) {
+      return;
+    }
+    const raw = await this.fileSystem.readFile(filePath);
+    if (!raw) {
+      return;
+    }
+    const json = typeof raw === "string" ? raw : new TextDecoder("utf-8").decode(raw);
+    return JSON.parse(json);
+  }
   async dispose() {}
 }
 // src/services/solution-tool.ts
@@ -1297,8 +1347,11 @@ class ToolsFactoryRepository {
   solutionFactory = null;
   registerProjectToolFactory(factory) {
     for (const type of factory.supportedTypes) {
-      if (this.projectFactoryMap.has(type)) {
-        console.warn(`Tool factory already registered for project type '${type}', skipping.`);
+      const existing = this.projectFactoryMap.get(type);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
         continue;
       }
       this.projectFactoryMap.set(type, factory);

package/dist/models/index.d.ts

@@ -14,5 +14,6 @@ export { TargetFramework } from "./target-frameworks.js";
 export type { ToolErrorCode } from "./tool-error-code.js";
 export { ToolErrorCodes } from "./tool-error-code.js";
 export { ToolResult } from "./tool-result.js";
+export type { UiProject } from "./ui-project.js";
 export type { UiPathProject } from "./uipath-project.js";
 export type { UiPathSolution } from "./uipath-solution.js";

package/dist/models/log-message.d.ts

@@ -15,7 +15,7 @@ export declare class LogMessage {
     line?: string;
     id?: string;
     readonly timestamp: Date;
-    constructor(message: string, logLevel: LogLevel, options?: {
+    constructor(message: string, logLevel: LogLevel | string, options?: {
         source?: string;
         sourceTarget?: string;
         progress?: number;
@@ -23,6 +23,8 @@ export declare class LogMessage {
         filePath?: string;
         line?: string;
         id?: string;
-    });
+    }, timestamp?: Date | string);
+    private static resolveTimestamp;
+    private static toLogLevel;
     toFormattedString(): string;
 }

package/dist/models/log-message.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/tool-result.d.ts

@@ -15,6 +15,10 @@ export declare class ToolResult {
      * List of packages produced
      */
     packages: string[];
+    /**
+     * Additional structured result data produced by a tool.
+     */
+    details?: Record<string, unknown>;
     constructor(errorCode: ToolErrorCode, message?: string, packages?: string[]);
     /**
      * Indicates whether the result represents a successful operation

package/dist/models/ui-project.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DTO matching the project.uiproj file format.
+ */
+export interface UiProject {
+    ProjectType: string;
+    /** Lowercase variant used by some project types (e.g., Flow) */
+    type?: string;
+    Name: string;
+    Description: string | null;
+    MainFile: string;
+}

package/dist/package-descriptor/package-descriptor-file-model.d.ts

@@ -3,6 +3,14 @@
  * Maps file identifiers to their relative paths
  */
 export interface PackageDescriptorFileModel {
+    /**
+     * Schema URL identifying the descriptor version. Orchestrator's
+     * package extractor reads this to dispatch between the legacy
+     * project.json pipeline and the operate.json/entry-points/bindings
+     * pipeline; omitting it routes the package through the legacy
+     * pipeline and metadata extraction may silently fail.
+     */
+    $schema?: string;
     /**
      * Map of file identifiers to relative paths
      * Key: file identifier (e.g., 'operate.json', 'entrypoints.json', 'bindings')

package/dist/services/content-operate-file.d.ts

@@ -0,0 +1,31 @@
+import type { IFileSystem } from "@uipath/filesystem";
+export interface ContentOperateFileParams {
+    /** The build's content/ folder (also where entry-points.json lives). */
+    contentFolder: string;
+    /** Already-resolved stable projectId to embed. */
+    projectId: string;
+    /** operate.json `contentType` for this tool (e.g. ProjectTypes.Api). */
+    contentType: string;
+}
+/**
+ * Ensure content/operate.json carries `projectId`. An existing file is
+ * backfilled in place; a missing one is scaffolded with the standard operate
+ * model for `contentType`, deriving `main` from entry-points.json. Shared by
+ * the packager tools that emit this same operate shape.
+ */
+export declare function writeContentOperateFile(fs: IFileSystem, params: ContentOperateFileParams): Promise<void>;
+export interface BuildContentOperateFileParams {
+    /** The build's content/ folder (also where entry-points.json lives). */
+    contentFolder: string;
+    /** Source project path used to read/persist a stable projectId. */
+    projectPath: string;
+    /** Orchestrator-supplied id; wins over a source-derived one when set. */
+    projectStorageId?: string;
+    /** operate.json `contentType` for this tool (e.g. ProjectTypes.Api). */
+    contentType: string;
+}
+/**
+ * Resolve a stable projectId (projectStorageId, else ensureProjectId on the
+ * source) and write content/operate.json via {@link writeContentOperateFile}.
+ */
+export declare function ensureContentOperateFile(fs: IFileSystem, params: BuildContentOperateFileParams): Promise<void>;

package/dist/services/project-id.d.ts

@@ -0,0 +1,18 @@
+import type { IFileSystem } from "@uipath/filesystem";
+/**
+ * Resolve a stable projectId for a project source directory, patching it
+ * into operate.json (or legacy project.json) if missing. Returns a fresh
+ * unpersisted UUID when neither file exists.
+ */
+export declare function ensureProjectId(projectPath: string, fs: IFileSystem): Promise<string>;
+/**
+ * Backfill `projectId` in an existing operate.json (preserving other
+ * fields). No-op if the file is missing, malformed, or already has a
+ * non-empty `projectId`.
+ */
+export declare function ensureProjectIdInOperateFile(operateFilePath: string, fallbackProjectId: string, fs: IFileSystem): Promise<void>;
+/**
+ * If `operateFilePath` already exists, backfill its `projectId` with
+ * `projectId`; otherwise invoke `createIfMissing` to scaffold it.
+ */
+export declare function writeOrBackfillOperateProjectId(operateFilePath: string, projectId: string, fs: IFileSystem, createIfMissing: () => Promise<void>): Promise<void>;

package/dist/services/project-tool.d.ts

@@ -1,6 +1,7 @@
 import type { IFileSystem } from "../filesystem/file-system.js";
 import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "../models/project-options.js";
 import { ToolResult } from "../models/tool-result.js";
+import type { UiProject } from "../models/ui-project.js";
 import type { IToolLogger } from "./tool-logger.js";
 /**
  * Base class for project tools.
@@ -8,6 +9,7 @@ import type { IToolLogger } from "./tool-logger.js";
 export declare abstract class ProjectTool {
     protected readonly fileSystem: IFileSystem;
     protected readonly logger: IToolLogger;
+    static readonly ProjectFileName = "project.uiproj";
     constructor(fileSystem: IFileSystem, logger: IToolLogger);
     /**
      * Restore project dependencies
@@ -25,6 +27,11 @@ export declare abstract class ProjectTool {
      * Pack project
      */
     packAsync(_options: IProjectPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Read and parse `project.uiproj` from the project folder.
+     * Returns `undefined` for project types that do not have a `project.uiproj`
+     */
+    protected getUiProjectAsync(projectPath: string): Promise<UiProject | undefined>;
     /**
      * Dispose resources - override in derived classes to clean up
      */

package/dist/services/tools-factory-repository.d.ts

@@ -49,7 +49,9 @@ export declare class ToolsFactoryRepository implements IToolsFactoryRepository,
     /**
      * Register a project tool factory.
      * Maps each of the factory's supported types to the factory.
-     * Warns and skips if a project type is already registered.
+     * Re-registering the same factory for a type is a silent no-op (expected
+     * when tools that bundle their own copy share a command path). A different
+     * factory claiming an already-registered type is a conflict and warns.
      */
     registerProjectToolFactory(factory: IProjectToolFactory): void;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/solutionpackager-tool-core",
-    "version": "0.0.33",
+    "version": "1.196.0",
     "description": "UiPath contracts for solution packager tools",
     "type": "module",
     "exports": {
@@ -10,19 +10,6 @@
         }
     },
     "types": "./dist/index.d.ts",
-    "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external fflate && tsc --emitDeclarationOnly --outDir dist",
-        "prepack": "bun run build",
-        "publish:dry": "bun publish --dry-run",
-        "publish:gh": "bun publish",
-        "version:patch": "bun version patch --no-git-tag-version",
-        "version:minor": "bun version minor --no-git-tag-version",
-        "version:major": "bun version major --no-git-tag-version",
-        "test": "vitest run",
-        "test:coverage": "vitest run --coverage",
-        "test:browser": "vitest run --config=vitest.browser.config.ts",
-        "lint": "biome check ."
-    },
     "files": [
         "dist",
         "!dist/**/*.map"
@@ -38,16 +25,16 @@
         "registry": "https://registry.npmjs.org/"
     },
     "devDependencies": {
-        "@types/node": "^25.5.0",
-        "@vitest/browser": "^4.0.14",
-        "@vitest/browser-playwright": "^4.0.14",
-        "@vitest/coverage-v8": "^4.0.14",
-        "typescript": "^5.9.3",
-        "vitest": "^4.0.14"
+        "@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": "0.9.0",
+        "@uipath/filesystem": "1.196.0",
         "fflate": "^0.8.2"
     },
-    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+    "gitHead": "bed2b46f1ec33a47a7dcae2e6d4b7ab99bd06981"
 }