@uipath/packager-tool-workflowcompiler-browser 0.0.29

package/src/i18n/locales/tr.json

@@ -0,0 +1,34 @@
+{
+    "toolWorkflowCompilerBrowser": {
+        "info": {
+            "startingRemotePackAgent": "Starting remote pack agent for {count} project(s): {paths}",
+            "connectingToHub": "Connecting to SignalR hub: {url}",
+            "remoteAgentStartedExecution": "Remote agent started execution",
+            "downloadingArchive": "Downloading pack result archive from bucket {bucketId}",
+            "extractingArchive": "Extracting archive ({size} bytes) to {path}",
+            "distributingPackages": "Distributing packages for {count} project(s)",
+            "cleaningUpTempDir": "Cleaning up temporary directory {path}",
+            "deletingBucket": "Deleting temporary storage bucket {bucketId}",
+            "copyingFiles": "Copying {count} file(s) for project {designId} to {path}"
+        },
+        "errors": {
+            "missingConnectionInfo": "Missing connection info (cloudUrl, accessToken, or folderId)",
+            "signalRConnectionFailed": "Failed to connect to SignalR hub",
+            "hubConnectionFailed": "Failed to connect to SignalR hub at {url}: {message}",
+            "packSucceededNoBucket": "Pack succeeded but no BucketId was returned",
+            "packAgentFailed": "Pack agent failed with status {status} (code {errorCode})",
+            "noResultForProject": "No result for project",
+            "beginSessionFailed": "BeginSession failed ({status}): {errorText}",
+            "hubConnectionClosed": "Hub connection closed unexpectedly",
+            "packAgentDisconnected": "Pack agent disconnected unexpectedly",
+            "deleteBucketFailed": "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+            "cleanupBucketFailed": "Unable to cleanup remote bucket {bucketId}: {message}",
+            "getBucketUriFailed": "Failed to get bucket read URI ({status}): {errorText}",
+            "downloadArchiveFailed": "Failed to download archive from bucket ({status}): {statusText}",
+            "noMatchingProject": "No matching project found for path: {projectPath}",
+            "noOutputForProject": "No output found for project {designId}",
+            "distributePackagesFailed": "Failed to distribute packages for {designId}: {message}",
+            "sessionTimeout": "Session timed out waiting for projects: received {received} of {expected} expected projects"
+        }
+    }
+}

package/src/i18n/locales/zh-CN.json

@@ -0,0 +1,34 @@
+{
+    "toolWorkflowCompilerBrowser": {
+        "info": {
+            "startingRemotePackAgent": "Starting remote pack agent for {count} project(s): {paths}",
+            "connectingToHub": "Connecting to SignalR hub: {url}",
+            "remoteAgentStartedExecution": "Remote agent started execution",
+            "downloadingArchive": "Downloading pack result archive from bucket {bucketId}",
+            "extractingArchive": "Extracting archive ({size} bytes) to {path}",
+            "distributingPackages": "Distributing packages for {count} project(s)",
+            "cleaningUpTempDir": "Cleaning up temporary directory {path}",
+            "deletingBucket": "Deleting temporary storage bucket {bucketId}",
+            "copyingFiles": "Copying {count} file(s) for project {designId} to {path}"
+        },
+        "errors": {
+            "missingConnectionInfo": "Missing connection info (cloudUrl, accessToken, or folderId)",
+            "signalRConnectionFailed": "Failed to connect to SignalR hub",
+            "hubConnectionFailed": "Failed to connect to SignalR hub at {url}: {message}",
+            "packSucceededNoBucket": "Pack succeeded but no BucketId was returned",
+            "packAgentFailed": "Pack agent failed with status {status} (code {errorCode})",
+            "noResultForProject": "No result for project",
+            "beginSessionFailed": "BeginSession failed ({status}): {errorText}",
+            "hubConnectionClosed": "Hub connection closed unexpectedly",
+            "packAgentDisconnected": "Pack agent disconnected unexpectedly",
+            "deleteBucketFailed": "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+            "cleanupBucketFailed": "Unable to cleanup remote bucket {bucketId}: {message}",
+            "getBucketUriFailed": "Failed to get bucket read URI ({status}): {errorText}",
+            "downloadArchiveFailed": "Failed to download archive from bucket ({status}): {statusText}",
+            "noMatchingProject": "No matching project found for path: {projectPath}",
+            "noOutputForProject": "No output found for project {designId}",
+            "distributePackagesFailed": "Failed to distribute packages for {designId}: {message}",
+            "sessionTimeout": "Session timed out waiting for projects: received {received} of {expected} expected projects"
+        }
+    }
+}

package/src/i18n/locales/zh-TW.json

@@ -0,0 +1,34 @@
+{
+    "toolWorkflowCompilerBrowser": {
+        "info": {
+            "startingRemotePackAgent": "Starting remote pack agent for {count} project(s): {paths}",
+            "connectingToHub": "Connecting to SignalR hub: {url}",
+            "remoteAgentStartedExecution": "Remote agent started execution",
+            "downloadingArchive": "Downloading pack result archive from bucket {bucketId}",
+            "extractingArchive": "Extracting archive ({size} bytes) to {path}",
+            "distributingPackages": "Distributing packages for {count} project(s)",
+            "cleaningUpTempDir": "Cleaning up temporary directory {path}",
+            "deletingBucket": "Deleting temporary storage bucket {bucketId}",
+            "copyingFiles": "Copying {count} file(s) for project {designId} to {path}"
+        },
+        "errors": {
+            "missingConnectionInfo": "Missing connection info (cloudUrl, accessToken, or folderId)",
+            "signalRConnectionFailed": "Failed to connect to SignalR hub",
+            "hubConnectionFailed": "Failed to connect to SignalR hub at {url}: {message}",
+            "packSucceededNoBucket": "Pack succeeded but no BucketId was returned",
+            "packAgentFailed": "Pack agent failed with status {status} (code {errorCode})",
+            "noResultForProject": "No result for project",
+            "beginSessionFailed": "BeginSession failed ({status}): {errorText}",
+            "hubConnectionClosed": "Hub connection closed unexpectedly",
+            "packAgentDisconnected": "Pack agent disconnected unexpectedly",
+            "deleteBucketFailed": "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+            "cleanupBucketFailed": "Unable to cleanup remote bucket {bucketId}: {message}",
+            "getBucketUriFailed": "Failed to get bucket read URI ({status}): {errorText}",
+            "downloadArchiveFailed": "Failed to download archive from bucket ({status}): {statusText}",
+            "noMatchingProject": "No matching project found for path: {projectPath}",
+            "noOutputForProject": "No output found for project {designId}",
+            "distributePackagesFailed": "Failed to distribute packages for {designId}: {message}",
+            "sessionTimeout": "Session timed out waiting for projects: received {received} of {expected} expected projects"
+        }
+    }
+}

package/src/i18n/locales/zu.json

@@ -0,0 +1,34 @@
+{
+    "toolWorkflowCompilerBrowser": {
+        "info": {
+            "startingRemotePackAgent": "Starting remote pack agent for {count} project(s): {paths}",
+            "connectingToHub": "Connecting to SignalR hub: {url}",
+            "remoteAgentStartedExecution": "Remote agent started execution",
+            "downloadingArchive": "Downloading pack result archive from bucket {bucketId}",
+            "extractingArchive": "Extracting archive ({size} bytes) to {path}",
+            "distributingPackages": "Distributing packages for {count} project(s)",
+            "cleaningUpTempDir": "Cleaning up temporary directory {path}",
+            "deletingBucket": "Deleting temporary storage bucket {bucketId}",
+            "copyingFiles": "Copying {count} file(s) for project {designId} to {path}"
+        },
+        "errors": {
+            "missingConnectionInfo": "Missing connection info (cloudUrl, accessToken, or folderId)",
+            "signalRConnectionFailed": "Failed to connect to SignalR hub",
+            "hubConnectionFailed": "Failed to connect to SignalR hub at {url}: {message}",
+            "packSucceededNoBucket": "Pack succeeded but no BucketId was returned",
+            "packAgentFailed": "Pack agent failed with status {status} (code {errorCode})",
+            "noResultForProject": "No result for project",
+            "beginSessionFailed": "BeginSession failed ({status}): {errorText}",
+            "hubConnectionClosed": "Hub connection closed unexpectedly",
+            "packAgentDisconnected": "Pack agent disconnected unexpectedly",
+            "deleteBucketFailed": "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+            "cleanupBucketFailed": "Unable to cleanup remote bucket {bucketId}: {message}",
+            "getBucketUriFailed": "Failed to get bucket read URI ({status}): {errorText}",
+            "downloadArchiveFailed": "Failed to download archive from bucket ({status}): {statusText}",
+            "noMatchingProject": "No matching project found for path: {projectPath}",
+            "noOutputForProject": "No output found for project {designId}",
+            "distributePackagesFailed": "Failed to distribute packages for {designId}: {message}",
+            "sessionTimeout": "Session timed out waiting for projects: received {received} of {expected} expected projects"
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+import "./i18n/index.js";
+import { WorkflowCompilerToolFactory } from "./workflow-compiler-tool-factory.js";
+
+toolsFactoryRepository.registerProjectToolFactory(
+    new WorkflowCompilerToolFactory(),
+);

package/src/pack-result-processor.ts

@@ -0,0 +1,309 @@
+import {
+    type ConnectionInfo,
+    type IFileSystem,
+    type IProjectPackOptions,
+    type IToolLogger,
+    type ProjectOperationContext,
+    ToolErrorCodes,
+    ToolResult,
+    toRelativeUrl,
+    translate,
+    ZipService,
+} from "@uipath/solutionpackager-tool-core";
+
+interface BlobFileAccessDto {
+    Uri: string;
+    Verb: string;
+    Headers: Record<string, string>;
+}
+
+interface ProjectResultEntry {
+    options: IProjectPackOptions;
+}
+
+export class PackResultProcessor {
+    private readonly zipService: ZipService;
+
+    constructor(
+        private readonly fileSystem: IFileSystem,
+        private readonly logger?: IToolLogger,
+    ) {
+        this.zipService = new ZipService(fileSystem);
+    }
+
+    async processAsync(
+        bucketId: number,
+        projects: Map<string, ProjectResultEntry>,
+        context: ProjectOperationContext,
+    ): Promise<Map<string, ToolResult>> {
+        const connection = context.connection!;
+        const results = new Map<string, ToolResult>();
+        const tempDir = await this.fileSystem.getTempDir();
+        const extractPath = `${tempDir}/pack-result-${context.id}`;
+
+        try {
+            this.logger?.info(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.info.downloadingArchive",
+                    { bucketId },
+                ),
+            );
+            const zipData = await this.downloadArchiveAsync(
+                bucketId,
+                connection,
+            );
+            this.logger?.info(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.info.extractingArchive",
+                    { size: zipData.length, path: extractPath },
+                ),
+            );
+            await this.zipService.extractAsync(zipData, extractPath);
+            this.logger?.info(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.info.distributingPackages",
+                    { count: projects.size },
+                ),
+            );
+            await this.distributePackages(
+                extractPath,
+                projects,
+                context,
+                results,
+            );
+        } catch (error) {
+            const message =
+                error instanceof Error ? error.message : String(error);
+            for (const [projectPath] of projects) {
+                if (!results.has(projectPath)) {
+                    results.set(
+                        projectPath,
+                        ToolResult.error("PackResultError", message),
+                    );
+                }
+            }
+        } finally {
+            this.logger?.info(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.info.cleaningUpTempDir",
+                    { path: extractPath },
+                ),
+            );
+            await this.fileSystem.rm(extractPath).catch(() => {});
+            await this.deleteBucketAsync(bucketId, connection);
+        }
+
+        return results;
+    }
+
+    private async downloadArchiveAsync(
+        bucketId: number,
+        connection: ConnectionInfo,
+    ): Promise<Uint8Array> {
+        const blobAccess = await this.getReadUriAsync(bucketId, connection);
+        return await this.downloadBlobAsync(blobAccess);
+    }
+
+    private async deleteBucketAsync(
+        bucketId: number,
+        connection: ConnectionInfo,
+    ): Promise<void> {
+        try {
+            if (!bucketId) {
+                return;
+            }
+
+            const baseUrl = toRelativeUrl(connection.cloudUrl!);
+            const url = `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})`;
+
+            this.logger?.info(
+                translate.t("toolWorkflowCompilerBrowser.info.deletingBucket", {
+                    bucketId,
+                }),
+            );
+
+            const response = await fetch(url, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${connection.accessToken}`,
+                    "X-UIPATH-OrganizationUnitId": connection.folderId ?? "",
+                },
+            });
+
+            if (!response.ok) {
+                throw new Error(
+                    translate.t(
+                        "toolWorkflowCompilerBrowser.errors.deleteBucketFailed",
+                        { statusText: response.statusText },
+                    ),
+                );
+            }
+        } catch (error) {
+            const message =
+                error instanceof Error ? error.message : String(error);
+            this.logger?.warn(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.cleanupBucketFailed",
+                    { bucketId, message },
+                ),
+            );
+        }
+    }
+
+    private async getReadUriAsync(
+        bucketId: number,
+        connection: ConnectionInfo,
+    ): Promise<BlobFileAccessDto> {
+        const baseUrl = toRelativeUrl(connection.cloudUrl!);
+        const url =
+            `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})` +
+            `/UiPath.Server.Configuration.OData.GetReadUri` +
+            `?path=rpa-packages.zip&expiryInMinutes=0`;
+
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${connection.accessToken}`,
+                "X-UIPATH-OrganizationUnitId": connection.folderId ?? "",
+            },
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.getBucketUriFailed",
+                    { status: response.status, errorText },
+                ),
+            );
+        }
+
+        return (await response.json()) as BlobFileAccessDto;
+    }
+
+    private async downloadBlobAsync(
+        blobAccess: BlobFileAccessDto,
+    ): Promise<Uint8Array> {
+        const headers: Record<string, string> = {};
+        if (blobAccess.Headers) {
+            for (const [key, value] of Object.entries(blobAccess.Headers)) {
+                headers[key] = value;
+            }
+        }
+
+        const response = await fetch(blobAccess.Uri, {
+            method: blobAccess.Verb || "GET",
+            headers,
+        });
+
+        if (!response.ok) {
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.downloadArchiveFailed",
+                    {
+                        status: response.status,
+                        statusText: response.statusText,
+                    },
+                ),
+            );
+        }
+
+        const buffer = await response.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+
+    private async distributePackages(
+        extractPath: string,
+        projects: Map<string, ProjectResultEntry>,
+        context: ProjectOperationContext,
+        results: Map<string, ToolResult>,
+    ): Promise<void> {
+        for (const [projectPath, entry] of projects) {
+            const project = context.solution.Projects.find(
+                (p) => p.ProjectPath === projectPath,
+            );
+
+            if (!project) {
+                results.set(
+                    projectPath,
+                    ToolResult.error(
+                        "PackResultError",
+                        translate.t(
+                            "toolWorkflowCompilerBrowser.errors.noMatchingProject",
+                            { projectPath },
+                        ),
+                    ),
+                );
+                continue;
+            }
+
+            const designId = project.Id;
+            const projectFilesDir = `${extractPath}/${designId}`;
+            const outputPath = entry.options.outputPath;
+
+            try {
+                const exists = await this.fileSystem.exists(projectFilesDir);
+                if (!exists) {
+                    results.set(
+                        projectPath,
+                        ToolResult.error(
+                            "PackResultError",
+                            translate.t(
+                                "toolWorkflowCompilerBrowser.errors.noOutputForProject",
+                                { designId },
+                            ),
+                        ),
+                    );
+                    continue;
+                }
+
+                const files = await this.fileSystem.readdir(projectFilesDir);
+                const outputFiles: string[] = [];
+
+                await this.fileSystem.mkdir(outputPath);
+                this.logger?.info(
+                    translate.t(
+                        "toolWorkflowCompilerBrowser.info.copyingFiles",
+                        {
+                            count: files.length,
+                            designId,
+                            path: outputPath,
+                        },
+                    ),
+                );
+
+                for (const fileName of files) {
+                    const srcFile = `${projectFilesDir}/${fileName}`;
+                    const destFile = `${outputPath}/${fileName}`;
+                    const data = await this.fileSystem.readFile(srcFile);
+                    if (data) {
+                        await this.fileSystem.writeFile(destFile, data);
+                        outputFiles.push(destFile);
+                    }
+                }
+
+                results.set(
+                    projectPath,
+                    new ToolResult(
+                        ToolErrorCodes.Success,
+                        undefined,
+                        outputFiles,
+                    ),
+                );
+            } catch (error) {
+                const message =
+                    error instanceof Error ? error.message : String(error);
+                results.set(
+                    projectPath,
+                    ToolResult.error(
+                        "PackResultError",
+                        translate.t(
+                            "toolWorkflowCompilerBrowser.errors.distributePackagesFailed",
+                            { designId, message },
+                        ),
+                    ),
+                );
+            }
+        }
+    }
+}