@uipath/solutionpackager-tool-core 0.0.26

package/dist/services/nuget-packager.js

@@ -0,0 +1,105 @@
+import { zipSync } from "fflate";
+import { Path } from "../filesystem/path.js";
+function escapeXml(str) {
+    if (null == str) return "";
+    return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function optionalElement(name, value) {
+    if (void 0 === value || "" === value) return "";
+    return `    <${name}>${escapeXml(value)}</${name}>\n`;
+}
+function generateDependenciesXml(dependencies) {
+    if (!dependencies || 0 === dependencies.length) return "";
+    const deps = dependencies.map((d)=>`      <dependency id="${escapeXml(d.id)}" version="${escapeXml(d.version)}" />`).join("\n");
+    return `    <dependencies>\n${deps}\n    </dependencies>\n`;
+}
+function generateRepositoryXml(packageInfo) {
+    if (!packageInfo.repositoryType || !packageInfo.repositoryUrl) return "";
+    let repoXml = `    <repository type="${escapeXml(packageInfo.repositoryType)}" url="${escapeXml(packageInfo.repositoryUrl)}"`;
+    if (packageInfo.repositoryBranch) repoXml += ` branch="${escapeXml(packageInfo.repositoryBranch)}"`;
+    if (packageInfo.repositoryCommit) repoXml += ` commit="${escapeXml(packageInfo.repositoryCommit)}"`;
+    repoXml += " />\n";
+    return repoXml;
+}
+function generateNuspecXml(packageInfo) {
+    const author = packageInfo.author?.trim() || "UiPath";
+    const description = packageInfo.description?.trim() || "Created by UiPath";
+    const title = packageInfo.title?.trim() || packageInfo.id;
+    const requireLicenseAcceptance = true === packageInfo.requireLicenseAcceptance ? "true" : "false";
+    const releaseNotes = packageInfo.releaseNotes ?? "";
+    const xml = `\uFEFF<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id>${escapeXml(packageInfo.id)}</id>
+    <version>${escapeXml(packageInfo.version)}</version>
+    <title>${escapeXml(title)}</title>
+    <authors>${escapeXml(author)}</authors>
+    <requireLicenseAcceptance>${requireLicenseAcceptance}</requireLicenseAcceptance>
+    <description>${escapeXml(description)}</description>
+    <releaseNotes>${escapeXml(releaseNotes)}</releaseNotes>
+${optionalElement("tags", packageInfo.tags)}${optionalElement("iconUrl", packageInfo.iconUrl)}${optionalElement("projectUrl", packageInfo.projectUrl)}${optionalElement("licenseUrl", packageInfo.licenseUrl)}${optionalElement("copyright", packageInfo.copyright)}${generateRepositoryXml(packageInfo)}${generateDependenciesXml(packageInfo.dependencies)}  </metadata>
+</package>
+`;
+    return xml;
+}
+function generatePsmdcpXml(packageInfo) {
+    const author = packageInfo.author?.trim() || "UiPath";
+    const description = packageInfo.description?.trim() || "Created by UiPath";
+    return `<?xml version="1.0" encoding="utf-8"?>
+<coreProperties xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties">
+  <dc:creator>${escapeXml(author)}</dc:creator>
+  <dc:description>${escapeXml(description)}</dc:description>
+  <dc:identifier>${escapeXml(packageInfo.id)}</dc:identifier>
+  <version>${escapeXml(packageInfo.version)}</version>
+  <keywords></keywords>
+  <lastModifiedBy>NuGet.Packaging, Version=6.12.1.1, Culture=neutral, PublicKeyToken=31bf3856ad364e35;.NET 5.0</lastModifiedBy>
+</coreProperties>`;
+}
+class NugetPackager {
+    fileSystem;
+    constructor(fileSystem){
+        this.fileSystem = fileSystem;
+    }
+    async packAsync(rootPath, packageInfo, outputPath) {
+        const normalizedOutputPath = Path.normalize(outputPath);
+        const nuspecXml = generateNuspecXml(packageInfo);
+        const nuspecFileName = `${packageInfo.id}.nuspec`;
+        const fileEntries = await Path.walkDirectory(this.fileSystem, rootPath);
+        const zipContents = {};
+        const encoder = new TextEncoder();
+        const psmdcpId = Array.from({
+            length: 4
+        }, ()=>Math.floor(0x100000000 * Math.random()).toString(16).padStart(8, "0")).join("");
+        const psmdcpFileName = `${psmdcpId}.psmdcp`;
+        const psmdcpPath = `package/services/metadata/core-properties/${psmdcpFileName}`;
+        const contentTypesXml = `<?xml version="1.0" encoding="utf-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
+  <Default Extension="psmdcp" ContentType="application/vnd.openxmlformats-package.core-properties+xml" />
+  <Default Extension="uiproj" ContentType="application/octet" />
+  <Default Extension="json" ContentType="application/octet" />
+  <Default Extension="nuspec" ContentType="application/octet" />
+</Types>`;
+        zipContents["[Content_Types].xml"] = encoder.encode(contentTypesXml);
+        const manifestRelId = `R${Date.now().toString(16).toUpperCase()}`;
+        const corePropsRelId = `R${(Date.now() + 1).toString(16).toUpperCase()}`;
+        const relsXml = `<?xml version="1.0" encoding="utf-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="/${nuspecFileName}" Id="${manifestRelId}" />
+  <Relationship Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="/${psmdcpPath}" Id="${corePropsRelId}" />
+</Relationships>`;
+        zipContents["_rels/.rels"] = encoder.encode(relsXml);
+        zipContents[psmdcpPath] = encoder.encode(generatePsmdcpXml(packageInfo));
+        zipContents[nuspecFileName] = encoder.encode(nuspecXml);
+        for (const entry of fileEntries){
+            const content = await this.fileSystem.readFile(entry.absolutePath);
+            if (null !== content) zipContents[entry.relativePath] = content;
+        }
+        const zippedData = zipSync(zipContents);
+        await this.fileSystem.writeFile(normalizedOutputPath, zippedData);
+        return {
+            outputPath: normalizedOutputPath
+        };
+    }
+}
+export { NugetPackager };

package/dist/services/project-operation-context.d.ts

@@ -0,0 +1,37 @@
+import type { ConnectionInfo } from "../models/connection-info.js";
+import type { TargetFramework } from "../models/target-frameworks.js";
+import type { UiPathSolution } from "../models/uipath-solution.js";
+import type { IToolLogger } from "./tool-logger.js";
+/**
+ * Context for a project operation, providing information about the solution and all projects involved
+ */
+export interface ProjectOperationContext {
+    /**
+     * Unique identifier for the operation
+     */
+    id: string;
+    /**
+     * Solution containing the projects involved in the operation
+     */
+    solution: UiPathSolution;
+    /**
+     * URL to download the solution snapshot for remote packing
+     */
+    downloadUrl?: string;
+    /**
+     * Build configuration (e.g. "Debug", "Release")
+     */
+    configuration: string;
+    /**
+     * Target framework for the package
+     */
+    targetFramework: TargetFramework;
+    /**
+     * Connection information for the remote service
+     */
+    connection?: ConnectionInfo;
+    /**
+     * Logger for the operation
+     */
+    logger?: IToolLogger;
+}

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

@@ -0,0 +1,21 @@
+import type { IFileSystem } from "../filesystem/file-system.js";
+import type { ProjectType } from "../models/project-type.js";
+import type { ProjectOperationContext } from "./project-operation-context.js";
+import type { ProjectTool } from "./project-tool.js";
+import type { IToolLogger } from "./tool-logger.js";
+/**
+ * Factory interface for creating ProjectTool instances
+ */
+export interface IProjectToolFactory {
+    /**
+     * The project types this factory can handle
+     */
+    readonly supportedTypes: readonly ProjectType[];
+    /**
+     * Create a project tool instance with the provided logger
+     * @param logger - The tool logger
+     * @param fileSystem - The file system instance
+     * @param context - Optional operation context with id and sibling project info
+     */
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem, context?: ProjectOperationContext): Promise<ProjectTool>;
+}

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

@@ -0,0 +1,32 @@
+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 { IToolLogger } from "./tool-logger.js";
+/**
+ * Base class for project tools.
+ */
+export declare abstract class ProjectTool {
+    protected readonly fileSystem: IFileSystem;
+    protected readonly logger: IToolLogger;
+    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    /**
+     * Restore project dependencies
+     */
+    restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Validate project
+     */
+    validateAsync(_options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Build project
+     */
+    buildAsync(_options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Pack project
+     */
+    packAsync(_options: IProjectPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Dispose resources - override in derived classes to clean up
+     */
+    dispose(): Promise<void>;
+}

package/dist/services/project-tool.js

@@ -0,0 +1,27 @@
+import { ToolResult } from "../models/tool-result.js";
+class ProjectTool {
+    fileSystem;
+    logger;
+    constructor(fileSystem, logger){
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    async restoreAsync(_options, _cancellationToken) {
+        this.logger.info("Restore operation is a noop");
+        return ToolResult.success();
+    }
+    async validateAsync(_options, _cancellationToken) {
+        this.logger.info("Validate operation is a noop");
+        return ToolResult.success();
+    }
+    async buildAsync(_options, _cancellationToken) {
+        this.logger.info("Build operation is a noop");
+        return ToolResult.success();
+    }
+    async packAsync(_options, _cancellationToken) {
+        this.logger.info("Pack operation is a noop");
+        return ToolResult.success();
+    }
+    async dispose() {}
+}
+export { ProjectTool };

package/dist/services/solution-tool-factory.d.ts

@@ -0,0 +1,14 @@
+import type { IFileSystem } from "../filesystem/file-system.js";
+import type { SolutionTool } from "./solution-tool.js";
+import type { IToolLogger } from "./tool-logger.js";
+/**
+ * Factory interface for creating SolutionTool instances
+ */
+export interface ISolutionToolFactory {
+    /**
+     * Create a solution tool instance with the provided logger
+     * @param logger - The tool logger
+     * @param fileSystem - The file system instance
+     */
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<SolutionTool>;
+}

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

@@ -0,0 +1,32 @@
+import type { IFileSystem } from "../filesystem/file-system.js";
+import type { ISolutionBuildOptions, ISolutionPackOptions, ISolutionRestoreOptions, ISolutionValidateOptions } from "../models/solution-options.js";
+import { ToolResult } from "../models/tool-result.js";
+import type { IToolLogger } from "./tool-logger.js";
+/**
+ * Base class for solution tools.
+ */
+export declare abstract class SolutionTool {
+    protected readonly fileSystem: IFileSystem;
+    protected readonly logger: IToolLogger;
+    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    /**
+     * Restore solution dependencies
+     */
+    restoreAsync(_options: ISolutionRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Validate solution
+     */
+    validateAsync(_options: ISolutionValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Build solution
+     */
+    buildAsync(_options: ISolutionBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Pack solution
+     */
+    packAsync(_options: ISolutionPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Dispose resources
+     */
+    dispose(): void | Promise<void>;
+}

package/dist/services/solution-tool.js

@@ -0,0 +1,27 @@
+import { ToolResult } from "../models/tool-result.js";
+class SolutionTool {
+    fileSystem;
+    logger;
+    constructor(fileSystem, logger){
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    async restoreAsync(_options, _cancellationToken) {
+        this.logger.info("Restore operation is a noop");
+        return ToolResult.success();
+    }
+    async validateAsync(_options, _cancellationToken) {
+        this.logger.info("Validate operation is a noop");
+        return ToolResult.success();
+    }
+    async buildAsync(_options, _cancellationToken) {
+        this.logger.info("Build operation is a noop");
+        return ToolResult.success();
+    }
+    async packAsync(_options, _cancellationToken) {
+        this.logger.info("Pack operation is a noop");
+        return ToolResult.success();
+    }
+    dispose() {}
+}
+export { SolutionTool };

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

@@ -0,0 +1,44 @@
+import type { LogLevel, LogMessage } from "../models/log-message.js";
+/**
+ * Options for log messages
+ */
+export interface LogOptions {
+    code?: string;
+    filePath?: string;
+    line?: string;
+    id?: string;
+}
+/**
+ * Interface for a logger that creates and outputs LogMessage instances
+ * Implementation is provided by the consumer (e.g., solutionpackager)
+ */
+export interface IToolLogger {
+    /**
+     * Log a debug level message
+     */
+    debug(message: string, options?: LogOptions): void;
+    /**
+     * Log an info level message
+     */
+    info(message: string, options?: LogOptions): void;
+    /**
+     * Log a warning level message
+     */
+    warn(message: string, options?: LogOptions): void;
+    /**
+     * Log an error level message
+     */
+    error(message: string, options?: LogOptions): void;
+    /**
+     * Log a progress message
+     */
+    progress(message: string, options?: LogOptions): void;
+    /**
+     * Log a message with a specific log level
+     */
+    log(message: string, logLevel: LogLevel, options?: LogOptions): void;
+    /**
+     * Log a pre-constructed LogMessage
+     */
+    logMessage(message: LogMessage): void;
+}

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

@@ -0,0 +1,84 @@
+import type { ProjectType } from "../models/project-type.js";
+import type { IProjectToolFactory } from "./project-tool-factory.js";
+import type { ISolutionToolFactory } from "./solution-tool-factory.js";
+/**
+ * Configurator interface for registering tool factories.
+ * Allows tools to register their project and solution tool factories.
+ */
+export interface IToolsFactoryRepositoryConfigurator {
+    /**
+     * Register a project tool factory
+     */
+    registerProjectToolFactory(factory: IProjectToolFactory): void;
+    /**
+     * Register the solution tool factory
+     */
+    registerSolutionToolFactory(factory: ISolutionToolFactory): void;
+}
+/**
+ * Repository interface providing access to registered project and solution tool factories.
+ */
+export interface IToolsFactoryRepository {
+    /**
+     * Get the solution tool factory
+     * @returns The registered solution tool factory
+     * @throws Error if no solution tool factory is registered
+     */
+    getSolutionToolFactory(): ISolutionToolFactory;
+    /**
+     * Check if there is a registered project tool factory for the specified project type
+     * @param projectType - The type of project
+     * @returns True if a factory is registered for the project type, false otherwise
+     */
+    canHandleProject(projectType: ProjectType): boolean;
+    /**
+     * Get the registered project tool factory for the specified project type
+     * @param projectType - The type of project
+     * @throws Error if no factory is registered for the project type
+     * @returns The registered factory
+     */
+    getProjectToolFactory(projectType: ProjectType): IProjectToolFactory;
+}
+/**
+ * Repository for managing tool factories.
+ * Implements both the configurator (for registration) and repository (for lookup) interfaces.
+ */
+export declare class ToolsFactoryRepository implements IToolsFactoryRepository, IToolsFactoryRepositoryConfigurator {
+    private projectFactoryMap;
+    private solutionFactory;
+    /**
+     * Register a project tool factory.
+     * Maps each of the factory's supported types to the factory.
+     * @throws Error if a project type is already registered by another factory
+     */
+    registerProjectToolFactory(factory: IProjectToolFactory): void;
+    /**
+     * Register the solution tool factory
+     */
+    registerSolutionToolFactory(factory: ISolutionToolFactory): void;
+    /**
+     * Get the solution tool factory
+     * @returns The registered solution tool factory
+     * @throws Error if no solution tool factory is registered
+     */
+    getSolutionToolFactory(): ISolutionToolFactory;
+    /**
+     * Check if there is a registered project tool factory for the specified project type
+     * @param projectType - The type of project
+     * @returns True if a factory is registered for the project type, false otherwise
+     */
+    canHandleProject(projectType: ProjectType): boolean;
+    /**
+     * Get the registered project tool factory for the specified project type
+     * @param projectType - The type of project
+     * @throws Error if no factory is registered for the project type
+     * @returns The registered factory
+     */
+    getProjectToolFactory(projectType: ProjectType): IProjectToolFactory;
+    /**
+     * Reset the repository by clearing all registered factories.
+     * Intended for use in tests only.
+     */
+    reset(): void;
+}
+export declare const toolsFactoryRepository: ToolsFactoryRepository;

package/dist/services/tools-factory-repository.js

@@ -0,0 +1,34 @@
+class ToolsFactoryRepository {
+    projectFactoryMap = new Map();
+    solutionFactory = null;
+    registerProjectToolFactory(factory) {
+        for (const type of factory.supportedTypes){
+            if (this.projectFactoryMap.has(type)) throw new Error(`A factory is already registered for project type '${type}'.`);
+            this.projectFactoryMap.set(type, factory);
+        }
+    }
+    registerSolutionToolFactory(factory) {
+        this.solutionFactory = factory;
+    }
+    getSolutionToolFactory() {
+        if (!this.solutionFactory) throw new Error("No solution tool factory is registered");
+        return this.solutionFactory;
+    }
+    canHandleProject(projectType) {
+        return this.projectFactoryMap.has(projectType);
+    }
+    getProjectToolFactory(projectType) {
+        const factory = this.projectFactoryMap.get(projectType);
+        if (!factory) throw new Error(`No tool factory found for project type '${projectType}'`);
+        return factory;
+    }
+    reset() {
+        this.projectFactoryMap.clear();
+        this.solutionFactory = null;
+    }
+}
+const REGISTRY_KEY = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+const _global = globalThis;
+if (!_global[REGISTRY_KEY]) _global[REGISTRY_KEY] = new ToolsFactoryRepository();
+const toolsFactoryRepository = _global[REGISTRY_KEY];
+export { ToolsFactoryRepository, toolsFactoryRepository };

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@uipath/solutionpackager-tool-core",
+    "version": "0.0.26",
+    "description": "UiPath contracts for solution packager tools",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "rslib build",
+        "test": "vitest run",
+        "test:browser": "vitest run --config=vitest.browser.config.ts",
+        "lint": "biome check ."
+    },
+    "files": [
+        "dist"
+    ],
+    "author": "",
+    "license": "ISC",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/Studio.Common.git",
+        "directory": "packager/uipath-solutionpackager-tool-core"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "devDependencies": {
+        "@rslib/core": "^0.20.0",
+        "@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"
+    },
+    "dependencies": {
+        "@uipath/filesystem": "^0.0.5",
+        "fflate": "^0.8.2"
+    }
+}