@uipath/packager-tool-workflowcompiler-browser 1.202.0-preview.140 → 1.202.0-preview.142

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

@@ -1,36 +0,0 @@
-{
-    "toolWorkflowCompilerBrowser": {
-        "info": {
-            "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}",
-            "offloadingInputArguments": "輸入引數過大（{length} 個字元），無法內嵌傳送；將以檔案附件形式上傳"
-        },
-        "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",
-            "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",
-            "createAttachmentFailed": "無法建立輸入引數附件 ({status})：{errorText}",
-            "attachmentResponseMalformed": "附件建立回應未包含 id 和 blob URI",
-            "uploadInputArgumentsFailed": "無法上傳輸入引數檔案 ({status})：{statusText}"
-        }
-    }
-}

package/src/i18n/locales/zu.json

@@ -1,36 +0,0 @@
-{
-    "toolWorkflowCompilerBrowser": {
-        "info": {
-            "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}",
-            "offloadingInputArguments": "Izimpikiswano zokufaka zinkulu kakhulu ({length} izinhlamvu) ukuze zithunyelwe ngaphakathi; zizolayishwa njengesinamathiselo sefayela"
-        },
-        "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",
-            "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",
-            "createAttachmentFailed": "Yehlulekile ukudala isinamathiselo sezimpikiswano zokufaka ({status}): {errorText}",
-            "attachmentResponseMalformed": "Impendulo yokudala isinamathiselo ayifakanga i-id ne-blob URI",
-            "uploadInputArgumentsFailed": "Yehlulekile ukulayisha ifayela lezimpikiswano zokufaka ({status}): {statusText}"
-        }
-    }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-import "./i18n/index.js";
-
-// Tool-specific cleanup detail. Surfaced via `ProjectCleanupInfo.toolDetails`;
-// only consumers that want WorkflowCompiler specifics import these types.
-export type {
-    CleanedWorkflowDetail,
-    WorkflowCleanupDetails,
-} from "./cleanup-result.js";
-// Workflow Compiler (browser) tool factory. Consumers register it explicitly via
-// `toolsFactoryRepository.registerProjectToolFactory(new WorkflowCompilerToolFactory())`.
-export { WorkflowCompilerToolFactory } from "./workflow-compiler-tool-factory.js";

package/src/pack-result-processor.ts

@@ -1,307 +0,0 @@
-import {
-    type ConnectionInfo,
-    type IFileSystem,
-    type IProjectPackOptions,
-    type IToolLogger,
-    type IZipService,
-    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 {
-    constructor(
-        private readonly fileSystem: IFileSystem,
-        private readonly logger?: IToolLogger,
-        private readonly zipService: IZipService = 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.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 },
-                        ),
-                    ),
-                );
-            }
-        }
-    }
-}

package/src/packager-hub-connection.ts

@@ -1,241 +0,0 @@
-import {
-    HttpTransportType,
-    type HubConnection,
-    HubConnectionBuilder,
-    HubConnectionState,
-} from "@microsoft/signalr";
-import {
-    type IToolLogger,
-    LogMessage,
-    translate,
-} from "@uipath/solutionpackager-tool-core";
-import type { RemoteProjectCleanup } from "./cleanup-result.js";
-
-/** @public */
-export enum CompletedStatus {
-    Succeeded = 0,
-    Stopped = 1,
-    Failed = 2,
-}
-
-export interface PackAgentResult {
-    errorCode: number;
-    status: CompletedStatus;
-    message?: string;
-    bucketId?: number;
-    /** Cleanup only: files changed per project design id, relative to each project. */
-    changedFilesByProject?: Record<string, string[]>;
-    /** Cleanup only: raw per-project cleanup payload, keyed by project design id. */
-    unusedDependenciesByProject?: Record<string, RemoteProjectCleanup>;
-}
-
-interface ExecutorCommand<T> {
-    Id: number;
-    Argument1: T;
-}
-
-interface PackJobResult {
-    ErrorCode: number;
-    Status: number;
-    Message?: string;
-    BucketId?: number;
-    ChangedFilesByProject?: Record<string, string[]>;
-    UnusedDependenciesByProject?: Record<string, RemoteProjectCleanup>;
-}
-
-enum PackagerCommandType {
-    PeerDisconnected = "PeerDisconnected",
-    SetLogMessage = "SetLogMessage",
-    SetExecutionStarted = "SetExecutionStarted",
-    SetExecutionCompleted = "SetExecutionCompleted",
-    Stop = "Stop",
-}
-
-export class PackagerHubConnection {
-    private hubConnection: HubConnection | null = null;
-    private completionResolve: ((result: PackAgentResult) => void) | null =
-        null;
-    private completionReject: ((error: Error) => void) | null = null;
-
-    constructor(private readonly logger?: IToolLogger) {}
-
-    async connectAsync(hubUrl: string, accessToken: string): Promise<void> {
-        try {
-            this.hubConnection = this.buildConnection(hubUrl, accessToken);
-            this.registerHandlers();
-            this.registerOnClose();
-            await this.hubConnection.start();
-        } catch (error) {
-            // Retry with SSE/LongPolling if WebSocket fails (matches StudioWeb pattern)
-            if (
-                error instanceof Error &&
-                error.message.toLowerCase().includes("websocket")
-            ) {
-                this.hubConnection = this.buildConnection(
-                    hubUrl,
-                    accessToken,
-                    true,
-                );
-                this.registerHandlers();
-                this.registerOnClose();
-                await this.hubConnection.start();
-            } else {
-                throw error;
-            }
-        }
-    }
-
-    private buildConnection(
-        hubUrl: string,
-        accessToken: string,
-        disableWs = false,
-    ): HubConnection {
-        return new HubConnectionBuilder()
-            .withUrl(hubUrl, {
-                accessTokenFactory: () => accessToken,
-                transport: disableWs
-                    ? HttpTransportType.ServerSentEvents |
-                      HttpTransportType.LongPolling
-                    : undefined,
-            })
-            .withAutomaticReconnect()
-            .build();
-    }
-
-    private registerOnClose(): void {
-        this.hubConnection?.onclose((error) => {
-            this.logger?.info(
-                `[PackagerHub] onclose fired. error=${error?.message ?? "none"}, hasReject=${!!this.completionReject}, hasResolve=${!!this.completionResolve}`,
-            );
-            if (this.completionReject) {
-                this.completionReject(
-                    error ??
-                        new Error(
-                            translate.t(
-                                "toolWorkflowCompilerBrowser.errors.hubConnectionClosed",
-                            ),
-                        ),
-                );
-                this.completionResolve = null;
-                this.completionReject = null;
-            }
-        });
-    }
-
-    waitForCompletionAsync(): Promise<PackAgentResult> {
-        return new Promise<PackAgentResult>((resolve, reject) => {
-            this.completionResolve = resolve;
-            this.completionReject = reject;
-        });
-    }
-
-    async disconnectAsync(): Promise<void> {
-        if (
-            this.hubConnection &&
-            this.hubConnection.state !== HubConnectionState.Disconnected
-        ) {
-            await this.hubConnection.stop();
-        }
-        this.hubConnection = null;
-    }
-
-    private registerHandlers(): void {
-        if (!this.hubConnection) return;
-
-        this.hubConnection.on(
-            PackagerCommandType.SetExecutionCompleted,
-            (jsonCommand: string) => {
-                this.onExecutionCompleted(jsonCommand);
-            },
-        );
-
-        this.hubConnection.on(
-            PackagerCommandType.SetLogMessage,
-            (jsonCommand: string) => {
-                this.onLogMessage(jsonCommand);
-            },
-        );
-
-        this.hubConnection.on(
-            PackagerCommandType.SetExecutionStarted,
-            (_jsonCommand: string) => {
-                this.logger?.info(
-                    translate.t(
-                        "toolWorkflowCompilerBrowser.info.remoteAgentStartedExecution",
-                    ),
-                );
-            },
-        );
-
-        this.hubConnection.on(PackagerCommandType.PeerDisconnected, () => {
-            this.logger?.info(
-                `[PackagerHub] PeerDisconnected received. hasReject=${!!this.completionReject}`,
-            );
-            if (this.completionReject) {
-                this.completionReject(
-                    new Error(
-                        translate.t(
-                            "toolWorkflowCompilerBrowser.errors.packAgentDisconnected",
-                        ),
-                    ),
-                );
-                this.completionResolve = null;
-                this.completionReject = null;
-            }
-        });
-    }
-
-    private onLogMessage(jsonCommand: string): void {
-        if (!this.logger) return;
-
-        const command: ExecutorCommand<LogMessage> = JSON.parse(jsonCommand);
-        const agentLog = command.Argument1;
-
-        const logMessage = new LogMessage(
-            agentLog.message,
-            agentLog.logLevel,
-            {
-                source: agentLog.source,
-                sourceTarget: agentLog.sourceTarget,
-                progress: agentLog.progress,
-                code: agentLog.code,
-                filePath: agentLog.filePath,
-                line: agentLog.line,
-                id: agentLog.id,
-            },
-            agentLog.timestamp,
-        );
-        this.logger.logMessage(logMessage);
-    }
-
-    private onExecutionCompleted(jsonCommand: string): void {
-        this.logger?.info(
-            `[PackagerHub] onExecutionCompleted called. hasResolve=${!!this.completionResolve}, raw=${jsonCommand}`,
-        );
-
-        if (!this.completionResolve) {
-            this.logger?.warn(
-                `[PackagerHub] onExecutionCompleted: completionResolve is null, ignoring result`,
-            );
-            return;
-        }
-
-        const command: ExecutorCommand<PackJobResult> = JSON.parse(jsonCommand);
-        const jobResult = command.Argument1;
-
-        this.logger?.info(
-            `[PackagerHub] onExecutionCompleted parsed: errorCode=${jobResult.ErrorCode}, status=${jobResult.Status}, message=${jobResult.Message}, bucketId=${jobResult.BucketId}`,
-        );
-
-        this.completionResolve({
-            errorCode: jobResult.ErrorCode,
-            status: jobResult.Status,
-            message: jobResult.Message,
-            bucketId: jobResult.BucketId,
-            changedFilesByProject: jobResult.ChangedFilesByProject,
-            unusedDependenciesByProject: jobResult.UnusedDependenciesByProject,
-        });
-        this.completionResolve = null;
-        this.completionReject = null;
-    }
-}