@uipath/packager-tool-workflowcompiler-browser 0.0.29

package/src/packager-hub-connection.ts

@@ -0,0 +1,257 @@
+import {
+    HttpTransportType,
+    type HubConnection,
+    HubConnectionBuilder,
+    HubConnectionState,
+} from "@microsoft/signalr";
+import {
+    type IToolLogger,
+    LogLevel,
+    LogMessage,
+    translate,
+} from "@uipath/solutionpackager-tool-core";
+
+/** @public */
+export enum CompletedStatus {
+    Succeeded = 0,
+    Stopped = 1,
+    Failed = 2,
+}
+
+export interface PackAgentResult {
+    errorCode: number;
+    status: CompletedStatus;
+    message?: string;
+    bucketId?: number;
+}
+
+interface ExecutorCommand<T> {
+    Id: number;
+    Argument1: T;
+}
+
+interface PackJobResult {
+    ErrorCode: number;
+    Status: number;
+    Message?: string;
+    BucketId?: number;
+}
+
+interface PackAgentLogMessage {
+    Message: string;
+    LogLevel: string;
+    Source?: string;
+    SourceTarget?: string;
+    Progress?: number;
+    Code?: string;
+    FilePath?: string;
+    Line?: string;
+    Id?: string;
+}
+
+function toLogLevel(level: string): LogLevel {
+    switch (level) {
+        case "Debug":
+            return LogLevel.Debug;
+        case "Information":
+            return LogLevel.Info;
+        case "Warning":
+            return LogLevel.Warn;
+        case "Error":
+            return LogLevel.Error;
+        default:
+            return LogLevel.Info;
+    }
+}
+
+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<PackAgentLogMessage> =
+            JSON.parse(jsonCommand);
+        const agentLog = command.Argument1;
+
+        const logLevel = toLogLevel(agentLog.LogLevel);
+        const logMessage = new LogMessage(agentLog.Message, logLevel, {
+            source: agentLog.Source,
+            sourceTarget: agentLog.SourceTarget,
+            progress: agentLog.Progress,
+            code: agentLog.Code,
+            filePath: agentLog.FilePath,
+            line: agentLog.Line,
+            id: agentLog.Id,
+        });
+        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,
+        });
+        this.completionResolve = null;
+        this.completionReject = null;
+    }
+}

package/src/project-bundle-executor.ts

@@ -0,0 +1,414 @@
+import {
+    type ConnectionInfo,
+    type IFileSystem,
+    type IProjectPackOptions,
+    type IProjectToolFactory,
+    type IToolLogger,
+    type ProjectOperationContext,
+    ToolResult,
+    toRelativeUrl,
+    translate,
+} from "@uipath/solutionpackager-tool-core";
+import { PackResultProcessor } from "./pack-result-processor.js";
+import {
+    CompletedStatus,
+    type PackAgentResult,
+    PackagerHubConnection,
+} from "./packager-hub-connection.js";
+
+type ResolveCallback = (result: ToolResult) => void;
+
+interface ProjectEntry {
+    options: IProjectPackOptions;
+    resolve: ResolveCallback;
+}
+
+interface BundleSession {
+    expectedCount: number;
+    projects: Map<string, ProjectEntry>;
+    timeout?: ReturnType<typeof setTimeout>;
+}
+
+export interface IProjectBundleExecutor {
+    packAsync(
+        options: IProjectPackOptions,
+        context: ProjectOperationContext,
+    ): Promise<ToolResult>;
+}
+
+/**
+ * Coordinates packing of multiple projects within a single operation context.
+ * Waits until all compatible projects have submitted their pack options,
+ * then executes a single bundled operation and resolves all pending promises.
+ */
+export class ProjectBundleExecutor implements IProjectBundleExecutor {
+    static readonly SESSION_TIMEOUT_MS = 1_800_000;
+
+    private readonly sessions = new Map<string, BundleSession>();
+    private readonly pendingSessionCreations = new Map<
+        string,
+        Promise<BundleSession>
+    >();
+
+    constructor(
+        private readonly toolFactory: IProjectToolFactory,
+        private readonly fileSystem: IFileSystem,
+    ) {}
+
+    async packAsync(
+        options: IProjectPackOptions,
+        context: ProjectOperationContext,
+    ): Promise<ToolResult> {
+        const projectPath = options.projectPath;
+        context.logger?.info(
+            `[BundleExecutor] packAsync called for project: ${projectPath}`,
+        );
+        const session = await this.getSessionAsync(context);
+
+        let resolve!: (result: ToolResult) => void;
+        const promise = new Promise<ToolResult>((r) => {
+            resolve = r;
+        });
+        session.projects.set(projectPath, { options, resolve });
+        const allReceived = session.projects.size === session.expectedCount;
+        context.logger?.info(
+            `[BundleExecutor] session: ${session.projects.size}/${session.expectedCount} projects received. allReceived=${allReceived}`,
+        );
+
+        if (allReceived) {
+            clearTimeout(session.timeout);
+            await this.packOnAgentAsync(session, context);
+            this.sessions.delete(context.id);
+        }
+
+        return promise;
+    }
+
+    private getSessionAsync(
+        context: ProjectOperationContext,
+    ): Promise<BundleSession> {
+        const existing = this.sessions.get(context.id);
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+
+        let pending = this.pendingSessionCreations.get(context.id);
+        if (!pending) {
+            pending = this.createSessionAsync(context);
+            this.pendingSessionCreations.set(context.id, pending);
+        }
+        return pending;
+    }
+
+    private async createSessionAsync(
+        context: ProjectOperationContext,
+    ): Promise<BundleSession> {
+        const expectedCount = this.countCompatibleProjects(context);
+        const session: BundleSession = {
+            expectedCount,
+            projects: new Map(),
+        };
+        session.timeout = setTimeout(() => {
+            if (session.projects.size < session.expectedCount) {
+                context.logger?.error(
+                    `[BundleExecutor] Session timed out after ${ProjectBundleExecutor.SESSION_TIMEOUT_MS}ms: ` +
+                        `received ${session.projects.size}/${session.expectedCount} projects`,
+                );
+                this.resolveAll(
+                    session,
+                    ToolResult.error(
+                        "SessionTimeoutError",
+                        translate.t(
+                            "toolWorkflowCompilerBrowser.errors.sessionTimeout",
+                            {
+                                received: session.projects.size,
+                                expected: session.expectedCount,
+                            },
+                        ),
+                    ),
+                );
+                this.sessions.delete(context.id);
+            }
+        }, ProjectBundleExecutor.SESSION_TIMEOUT_MS);
+        this.sessions.set(context.id, session);
+        this.pendingSessionCreations.delete(context.id);
+        return session;
+    }
+
+    private async packOnAgentAsync(
+        session: BundleSession,
+        context: ProjectOperationContext,
+    ): Promise<void> {
+        const projectPaths = [...session.projects.keys()];
+        context.logger?.info(
+            translate.t(
+                "toolWorkflowCompilerBrowser.info.startingRemotePackAgent",
+                {
+                    count: session.expectedCount,
+                    paths: projectPaths.join(", "),
+                },
+            ),
+        );
+
+        const connection = context.connection;
+        context.logger?.info(
+            `[BundleExecutor] connection info: cloudUrl=${connection?.cloudUrl ?? "MISSING"}, hasToken=${!!connection?.accessToken}, folderId=${connection?.folderId ?? "MISSING"}`,
+        );
+        if (
+            !connection?.cloudUrl ||
+            !connection.accessToken ||
+            !connection.folderId
+        ) {
+            this.resolveAll(
+                session,
+                ToolResult.error(
+                    "ConnectionError",
+                    translate.t(
+                        "toolWorkflowCompilerBrowser.errors.missingConnectionInfo",
+                    ),
+                ),
+            );
+            return;
+        }
+
+        const sessionId = crypto.randomUUID();
+        const hubConnection = await this.connectToHubAsync(
+            connection,
+            sessionId,
+            context.logger,
+        );
+        if (!hubConnection) {
+            this.resolveAll(
+                session,
+                ToolResult.error(
+                    "SignalRConnectionError",
+                    translate.t(
+                        "toolWorkflowCompilerBrowser.errors.signalRConnectionFailed",
+                    ),
+                ),
+            );
+            return;
+        }
+
+        try {
+            context.logger?.info(`[BundleExecutor] Sending BeginSession...`);
+            await this.sendBeginSessionAsync(
+                session,
+                context,
+                connection,
+                sessionId,
+            );
+            context.logger?.info(
+                `[BundleExecutor] BeginSession succeeded. Waiting for completion...`,
+            );
+            const result = await hubConnection.waitForCompletionAsync();
+            context.logger?.info(
+                `[BundleExecutor] Got result: errorCode=${result.errorCode}, status=${result.status}, message=${result.message}, bucketId=${result.bucketId}`,
+            );
+            await this.handlePackResultAsync(result, session, context);
+        } catch (error) {
+            const message =
+                error instanceof Error ? error.message : String(error);
+            context.logger?.error(
+                `[BundleExecutor] packOnAgentAsync caught error: ${message}`,
+            );
+            this.resolveAll(
+                session,
+                ToolResult.error("PackAgentError", message),
+            );
+        } finally {
+            await hubConnection.disconnectAsync();
+        }
+    }
+
+    private async connectToHubAsync(
+        connection: ConnectionInfo,
+        sessionId: string,
+        logger?: IToolLogger,
+    ): Promise<PackagerHubConnection | null> {
+        const relativeBase = toRelativeUrl(connection.cloudUrl!);
+        const hubUrl = `${relativeBase}/orchestrator_/signalr/robotdebug?sessionId=${sessionId}`;
+        logger?.info(
+            translate.t("toolWorkflowCompilerBrowser.info.connectingToHub", {
+                url: hubUrl,
+            }),
+        );
+
+        const hubConnection = new PackagerHubConnection(logger);
+        try {
+            await hubConnection.connectAsync(hubUrl, connection.accessToken!);
+            return hubConnection;
+        } catch (error) {
+            const message =
+                error instanceof Error ? error.message : String(error);
+            logger?.error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.hubConnectionFailed",
+                    { url: hubUrl, message },
+                ),
+            );
+            return null;
+        }
+    }
+
+    private async handlePackResultAsync(
+        result: PackAgentResult,
+        session: BundleSession,
+        context: ProjectOperationContext,
+    ): Promise<void> {
+        if (
+            result.errorCode !== 0 ||
+            result.status !== CompletedStatus.Succeeded
+        ) {
+            this.resolveAll(
+                session,
+                ToolResult.error(
+                    "PackAgentError",
+                    result.message ??
+                        translate.t(
+                            "toolWorkflowCompilerBrowser.errors.packAgentFailed",
+                            {
+                                status: result.status,
+                                errorCode: result.errorCode,
+                            },
+                        ),
+                ),
+            );
+            return;
+        }
+
+        if (result.bucketId == null) {
+            this.resolveAll(
+                session,
+                ToolResult.error(
+                    "PackAgentError",
+                    translate.t(
+                        "toolWorkflowCompilerBrowser.errors.packSucceededNoBucket",
+                    ),
+                ),
+            );
+            return;
+        }
+
+        const resultProcessor = new PackResultProcessor(
+            this.fileSystem,
+            context.logger,
+        );
+        const perProjectResults = await resultProcessor.processAsync(
+            result.bucketId,
+            session.projects,
+            context,
+        );
+        for (const [projectPath, entry] of session.projects) {
+            const projectResult = perProjectResults.get(projectPath);
+            entry.resolve(
+                projectResult ??
+                    ToolResult.error(
+                        "PackResultError",
+                        translate.t(
+                            "toolWorkflowCompilerBrowser.errors.noResultForProject",
+                        ),
+                    ),
+            );
+        }
+    }
+
+    private async sendBeginSessionAsync(
+        session: BundleSession,
+        context: ProjectOperationContext,
+        connection: ConnectionInfo,
+        sessionId: string,
+    ): Promise<void> {
+        const relativeBase = toRelativeUrl(connection.cloudUrl!);
+        const url = `${relativeBase}/orchestrator_/api/serverless/jobs`;
+        context.logger?.info(`[BundleExecutor] BeginSession URL: ${url}`);
+
+        // Use the first entry for shared fields (package info, options)
+        const firstEntry = session.projects.values().next().value!;
+        const pkg = firstEntry.options.package;
+        const opts = firstEntry.options;
+
+        // Build RpaProjects from all projects in the session
+        const rpaProjects = [...session.projects.entries()].map(
+            ([projectPath, entry]) => {
+                const project = context.solution.Projects.find(
+                    (p) => p.ProjectPath === projectPath,
+                );
+                return {
+                    RelativePath: project?.ProjectRelativePath ?? "",
+                    DesignId: project?.Id ?? "",
+                    PackageId: entry.options.package.id,
+                };
+            },
+        );
+
+        const executorInfo = JSON.stringify({
+            Command: "Pack",
+            SupportedProtocolVersions: ["2.0"],
+            ProjectId: "",
+            DownloadUrl: context.downloadUrl ?? "",
+            SessionId: sessionId,
+            ProfileKey: "StudioWeb",
+            LicenseType: "Development",
+            LogLevel: opts.logLevel ?? "Warning",
+            Name: pkg.id,
+            Configuration: context.configuration,
+            Culture: "en-US",
+            Version: pkg.version,
+            Author: pkg.author ?? "",
+            Description: pkg.description ?? "",
+            SkipAnalyze: String(opts.skipAnalyze),
+            SkipValidate: String(opts.skipValidate),
+            TargetFramework: context.targetFramework,
+            RpaProjects: rpaProjects,
+            WorkflowCompilerVersion: context.workflowCompilerVersion ?? "",
+        });
+
+        const body = {
+            source: "StudioWeb",
+            targetFramework: context.targetFramework,
+            jobType: "PublishStudioProject",
+            inputArguments: executorInfo,
+        };
+
+        const headers: Record<string, string> = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${connection.accessToken}`,
+            "X-UIPATH-OrganizationUnitId": connection.folderId ?? "",
+        };
+
+        if (connection.tenantId) {
+            headers["x-uipath-tenantid"] = connection.tenantId;
+        }
+
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.beginSessionFailed",
+                    { status: response.status, errorText },
+                ),
+            );
+        }
+    }
+
+    private resolveAll(session: BundleSession, result: ToolResult): void {
+        for (const [, entry] of session.projects) {
+            entry.resolve(result);
+        }
+    }
+
+    private countCompatibleProjects(context: ProjectOperationContext): number {
+        return context.solution.Projects.filter(
+            (p) =>
+                p.ProjectPath != null &&
+                this.toolFactory.supportedTypes.includes(p.Type),
+        ).length;
+    }
+}