@uipath/packager-tool-workflowcompiler-browser 0.0.29 → 1.196.0

package/src/project-bundle-executor.ts

@@ -3,6 +3,7 @@ import {
     type IFileSystem,
     type IProjectPackOptions,
     type IProjectToolFactory,
+    type IProjectValidateOptions,
     type IToolLogger,
     type ProjectOperationContext,
     ToolResult,
@@ -18,12 +19,27 @@ import {
 
 type ResolveCallback = (result: ToolResult) => void;
 
-interface ProjectEntry {
+export enum BundleOperation {
+    Pack = "Pack",
+    Validate = "Validate",
+}
+
+interface PackEntry {
+    operation: BundleOperation.Pack;
     options: IProjectPackOptions;
     resolve: ResolveCallback;
 }
 
+interface ValidateEntry {
+    operation: BundleOperation.Validate;
+    options: IProjectValidateOptions;
+    resolve: ResolveCallback;
+}
+
+type ProjectEntry = PackEntry | ValidateEntry;
+
 interface BundleSession {
+    operation: BundleOperation;
     expectedCount: number;
     projects: Map<string, ProjectEntry>;
     timeout?: ReturnType<typeof setTimeout>;
@@ -34,16 +50,40 @@ export interface IProjectBundleExecutor {
         options: IProjectPackOptions,
         context: ProjectOperationContext,
     ): Promise<ToolResult>;
+
+    validateAsync(
+        options: IProjectValidateOptions,
+        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.
+ * Coordinates pack or validate of multiple projects within a single operation context.
+ * Waits until all compatible projects have submitted their options,
+ * then executes a single bundled remote-agent operation and resolves all pending promises.
+ */
+/**
+ * Shape of the `POST /odata/Attachments` response. Orchestrator returns
+ * PascalCase (`Id`, `BlobFileAccess.Uri`); the camelCase fallbacks mirror the
+ * defensive reads in `@uipath/orchestrator-sdk`'s `uploadJobAttachment`.
  */
+interface AttachmentResponse {
+    Id?: string;
+    id?: string;
+    BlobFileAccess?: { Uri: string };
+    blobFileAccess?: { Uri: string };
+}
+
 export class ProjectBundleExecutor implements IProjectBundleExecutor {
     static readonly SESSION_TIMEOUT_MS = 1_800_000;
 
+    /**
+     * Maximum length (in characters) of the inline `inputArguments` payload
+     * accepted by the serverless jobs endpoint. Beyond this the arguments must
+     * be uploaded as a file attachment and referenced via `inputFile`.
+     */
+    static readonly MAX_INLINE_INPUT_ARGUMENTS_LENGTH = 10_000;
+
     private readonly sessions = new Map<string, BundleSession>();
     private readonly pendingSessionCreations = new Map<
         string,
@@ -59,25 +99,59 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
         options: IProjectPackOptions,
         context: ProjectOperationContext,
     ): Promise<ToolResult> {
-        const projectPath = options.projectPath;
+        return this.enqueueAsync(context, {
+            operation: BundleOperation.Pack,
+            options,
+            resolve: () => {},
+        });
+    }
+
+    async validateAsync(
+        options: IProjectValidateOptions,
+        context: ProjectOperationContext,
+    ): Promise<ToolResult> {
+        return this.enqueueAsync(context, {
+            operation: BundleOperation.Validate,
+            options,
+            resolve: () => {},
+        });
+    }
+
+    private async enqueueAsync(
+        context: ProjectOperationContext,
+        entry: ProjectEntry,
+    ): Promise<ToolResult> {
+        const projectPath = entry.options.projectPath;
         context.logger?.info(
-            `[BundleExecutor] packAsync called for project: ${projectPath}`,
+            `[BundleExecutor] ${entry.operation}Async called for project: ${projectPath}`,
         );
-        const session = await this.getSessionAsync(context);
+        const session = await this.getSessionAsync(context, entry.operation);
 
-        let resolve!: (result: ToolResult) => void;
-        const promise = new Promise<ToolResult>((r) => {
-            resolve = r;
+        if (session.operation !== entry.operation) {
+            return ToolResult.error(
+                "BundleOperationMismatch",
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.bundleOperationMismatch",
+                    {
+                        sessionOperation: session.operation,
+                        entryOperation: entry.operation,
+                    },
+                ),
+            );
+        }
+
+        const promise = new Promise<ToolResult>((resolve) => {
+            entry.resolve = resolve;
         });
-        session.projects.set(projectPath, { options, resolve });
+        session.projects.set(projectPath, entry);
         const allReceived = session.projects.size === session.expectedCount;
         context.logger?.info(
-            `[BundleExecutor] session: ${session.projects.size}/${session.expectedCount} projects received. allReceived=${allReceived}`,
+            `[BundleExecutor] session (${session.operation}): ${session.projects.size}/${session.expectedCount} projects received. allReceived=${allReceived}`,
         );
 
         if (allReceived) {
             clearTimeout(session.timeout);
-            await this.packOnAgentAsync(session, context);
+            await this.runAgentAsync(session, context);
             this.sessions.delete(context.id);
         }
 
@@ -86,6 +160,7 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
 
     private getSessionAsync(
         context: ProjectOperationContext,
+        operation: BundleOperation,
     ): Promise<BundleSession> {
         const existing = this.sessions.get(context.id);
         if (existing) {
@@ -94,7 +169,7 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
 
         let pending = this.pendingSessionCreations.get(context.id);
         if (!pending) {
-            pending = this.createSessionAsync(context);
+            pending = this.createSessionAsync(context, operation);
             this.pendingSessionCreations.set(context.id, pending);
         }
         return pending;
@@ -102,9 +177,11 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
 
     private async createSessionAsync(
         context: ProjectOperationContext,
+        operation: BundleOperation,
     ): Promise<BundleSession> {
         const expectedCount = this.countCompatibleProjects(context);
         const session: BundleSession = {
+            operation,
             expectedCount,
             projects: new Map(),
         };
@@ -135,15 +212,16 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
         return session;
     }
 
-    private async packOnAgentAsync(
+    private async runAgentAsync(
         session: BundleSession,
         context: ProjectOperationContext,
     ): Promise<void> {
         const projectPaths = [...session.projects.keys()];
         context.logger?.info(
             translate.t(
-                "toolWorkflowCompilerBrowser.info.startingRemotePackAgent",
+                "toolWorkflowCompilerBrowser.info.startingRemoteAgent",
                 {
+                    operation: session.operation,
                     count: session.expectedCount,
                     paths: projectPaths.join(", "),
                 },
@@ -205,16 +283,16 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
             context.logger?.info(
                 `[BundleExecutor] Got result: errorCode=${result.errorCode}, status=${result.status}, message=${result.message}, bucketId=${result.bucketId}`,
             );
-            await this.handlePackResultAsync(result, session, context);
+            await this.handleAgentResultAsync(result, session, context);
         } catch (error) {
             const message =
                 error instanceof Error ? error.message : String(error);
             context.logger?.error(
-                `[BundleExecutor] packOnAgentAsync caught error: ${message}`,
+                `[BundleExecutor] runAgentAsync caught error: ${message}`,
             );
             this.resolveAll(
                 session,
-                ToolResult.error("PackAgentError", message),
+                ToolResult.error(`${session.operation}AgentError`, message),
             );
         } finally {
             await hubConnection.disconnectAsync();
@@ -251,7 +329,7 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
         }
     }
 
-    private async handlePackResultAsync(
+    private async handleAgentResultAsync(
         result: PackAgentResult,
         session: BundleSession,
         context: ProjectOperationContext,
@@ -263,11 +341,12 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
             this.resolveAll(
                 session,
                 ToolResult.error(
-                    "PackAgentError",
+                    `${session.operation}AgentError`,
                     result.message ??
                         translate.t(
-                            "toolWorkflowCompilerBrowser.errors.packAgentFailed",
+                            "toolWorkflowCompilerBrowser.errors.agentFailed",
                             {
+                                operation: session.operation,
                                 status: result.status,
                                 errorCode: result.errorCode,
                             },
@@ -277,6 +356,19 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
             return;
         }
 
+        if (session.operation === BundleOperation.Pack) {
+            await this.handlePackBucketAsync(result, session, context);
+            return;
+        }
+
+        this.resolveAll(session, ToolResult.success());
+    }
+
+    private async handlePackBucketAsync(
+        result: PackAgentResult,
+        session: BundleSession,
+        context: ProjectOperationContext,
+    ): Promise<void> {
         if (result.bucketId == null) {
             this.resolveAll(
                 session,
@@ -290,13 +382,20 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
             return;
         }
 
+        const packEntries = new Map<string, { options: IProjectPackOptions }>();
+        for (const [projectPath, entry] of session.projects) {
+            if (entry.operation === BundleOperation.Pack) {
+                packEntries.set(projectPath, { options: entry.options });
+            }
+        }
+
         const resultProcessor = new PackResultProcessor(
             this.fileSystem,
             context.logger,
         );
         const perProjectResults = await resultProcessor.processAsync(
             result.bucketId,
-            session.projects,
+            packEntries,
             context,
         );
         for (const [projectPath, entry] of session.projects) {
@@ -321,56 +420,107 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
     ): Promise<void> {
         const relativeBase = toRelativeUrl(connection.cloudUrl!);
         const url = `${relativeBase}/orchestrator_/api/serverless/jobs`;
+        //const url = `${relativeBase}/orchestrator_/api/RobotDebug/BeginSession`;
+
         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(
+                const project = context.projects.find(
                     (p) => p.ProjectPath === projectPath,
                 );
                 return {
                     RelativePath: project?.ProjectRelativePath ?? "",
                     DesignId: project?.Id ?? "",
-                    PackageId: entry.options.package.id,
+                    ProjectStorageId:
+                        entry.operation === BundleOperation.Pack
+                            ? (entry.options.projectStorageId ?? "")
+                            : "",
+                    PackageId:
+                        entry.operation === BundleOperation.Pack
+                            ? entry.options.package.id
+                            : "",
                 };
             },
         );
 
-        const executorInfo = JSON.stringify({
-            Command: "Pack",
+        const executorInfo: Record<string, unknown> = {
+            Command: session.operation,
             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 ?? "",
+            DownloadTimeoutInSeconds: 300,
             SkipAnalyze: String(opts.skipAnalyze),
             SkipValidate: String(opts.skipValidate),
             TargetFramework: context.targetFramework,
             RpaProjects: rpaProjects,
             WorkflowCompilerVersion: context.workflowCompilerVersion ?? "",
-        });
+        };
+
+        if (firstEntry.operation === BundleOperation.Pack) {
+            executorInfo.Configuration = context.configuration;
+            const pkg = firstEntry.options.package;
+            executorInfo.Package = {
+                Name: pkg.id,
+                Version: pkg.version,
+                Author: pkg.author ?? "",
+                Description: pkg.description ?? "",
+                ReleaseNotes: pkg.releaseNotes ?? "",
+                Tags: pkg.tags ?? "",
+                IconUrl: pkg.iconUrl ?? "",
+                ProjectUrl: pkg.projectUrl ?? "",
+                RepositoryType: pkg.repositoryType ?? "",
+                RepositoryUrl: pkg.repositoryUrl ?? "",
+                RepositoryBranch: pkg.repositoryBranch ?? "",
+                RepositoryCommit: pkg.repositoryCommit ?? "",
+            };
+            // Flat fields retained for backward compatibility with agents that
+            // predate the nested Package structure.
+            executorInfo.Name = pkg.id;
+            executorInfo.Version = pkg.version;
+            executorInfo.Author = pkg.author ?? "";
+            executorInfo.Description = pkg.description ?? "";
+            executorInfo.ReleaseNotes = pkg.releaseNotes ?? "";
+        }
+
+        const inputArguments = JSON.stringify(executorInfo);
 
-        const body = {
+        const body: Record<string, unknown> = {
             source: "StudioWeb",
             targetFramework: context.targetFramework,
             jobType: "PublishStudioProject",
-            inputArguments: executorInfo,
         };
 
+        // The serverless jobs endpoint caps inline inputArguments at
+        // MAX_INLINE_INPUT_ARGUMENTS_LENGTH characters. For larger payloads we
+        // upload the arguments as a file attachment and reference it via
+        // inputFile instead (the two are mutually exclusive on the server).
+        if (
+            inputArguments.length >
+            ProjectBundleExecutor.MAX_INLINE_INPUT_ARGUMENTS_LENGTH
+        ) {
+            context.logger?.info(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.info.offloadingInputArguments",
+                    { length: inputArguments.length },
+                ),
+            );
+            body.inputFile = await this.uploadInputArgumentsFileAsync(
+                inputArguments,
+                connection,
+                context.logger,
+            );
+        } else {
+            body.inputArguments = inputArguments;
+        }
+
         const headers: Record<string, string> = {
             "Content-Type": "application/json",
             Authorization: `Bearer ${connection.accessToken}`,
@@ -398,6 +548,86 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
         }
     }
 
+    /**
+     * Uploads the input arguments JSON as a file attachment and returns the
+     * attachment id, to be passed as `inputFile` on the serverless job request.
+     * Mirrors the two-step flow used by the Orchestrator UI: create the
+     * attachment (which returns a signed blob write URI) then PUT the contents
+     * to that URI using the storage-provided headers.
+     */
+    private async uploadInputArgumentsFileAsync(
+        inputArguments: string,
+        connection: ConnectionInfo,
+        logger?: IToolLogger,
+    ): Promise<string> {
+        const baseUrl = toRelativeUrl(connection.cloudUrl!);
+        const attachmentsUrl = `${baseUrl}/orchestrator_/odata/Attachments`;
+
+        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 createResponse = await fetch(attachmentsUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ name: "input.json" }),
+        });
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.createAttachmentFailed",
+                    { status: createResponse.status, errorText },
+                ),
+            );
+        }
+
+        const attachment = (await createResponse.json()) as AttachmentResponse;
+        const attachmentId = attachment.Id ?? attachment.id ?? "";
+        const writeUri =
+            attachment.BlobFileAccess?.Uri ?? attachment.blobFileAccess?.Uri;
+        if (!attachmentId || !writeUri) {
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.attachmentResponseMalformed",
+                ),
+            );
+        }
+
+        // PUT the raw bytes to the SAS blob URI. The Azure blob endpoint
+        // requires the BlockBlob type header; matches the proven contract in
+        // `@uipath/orchestrator-sdk`'s uploadJobAttachment.
+        const uploadResponse = await fetch(writeUri, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/octet-stream",
+                "x-ms-blob-type": "BlockBlob",
+            },
+            body: inputArguments,
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(
+                translate.t(
+                    "toolWorkflowCompilerBrowser.errors.uploadInputArgumentsFailed",
+                    {
+                        status: uploadResponse.status,
+                        statusText: uploadResponse.statusText,
+                    },
+                ),
+            );
+        }
+
+        logger?.info(
+            `[BundleExecutor] Uploaded input arguments as attachment ${attachmentId}`,
+        );
+        return attachmentId;
+    }
+
     private resolveAll(session: BundleSession, result: ToolResult): void {
         for (const [, entry] of session.projects) {
             entry.resolve(result);
@@ -405,7 +635,7 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
     }
 
     private countCompatibleProjects(context: ProjectOperationContext): number {
-        return context.solution.Projects.filter(
+        return context.projects.filter(
             (p) =>
                 p.ProjectPath != null &&
                 this.toolFactory.supportedTypes.includes(p.Type),

package/src/workflow-compiler-tool.ts

@@ -7,14 +7,16 @@ import {
     type IToolLogger,
     type ProjectOperationContext,
     ProjectTool,
+    ToolErrorCodes,
     ToolResult,
 } from "@uipath/solutionpackager-tool-core";
 import type { IProjectBundleExecutor } from "./project-bundle-executor.js";
 
 /**
  * Browser workflow compiler tool implementation.
- * DUMMY: Logs messages indicating where robot/remote agent integration will be added.
- * Future: Will send pack commands to robot which starts remote agent to pack projects.
+ * Delegates pack and validate to a bundle executor that coordinates a
+ * single remote-agent invocation across all compatible projects in the
+ * solution via SignalR.
  */
 export class WorkflowCompilerTool extends ProjectTool {
     constructor(
@@ -37,13 +39,17 @@ export class WorkflowCompilerTool extends ProjectTool {
     }
 
     async validateAsync(
-        _options: IProjectValidateOptions,
+        options: IProjectValidateOptions,
         _cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        this.logger.warn(
-            "Validate operation is not supported in browser environment",
-        );
-        return ToolResult.success();
+        if (!this.context) {
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                "Validate operation requires a project operation context",
+            );
+        }
+
+        return this.bundleExecutor.validateAsync(options, this.context);
     }
 
     async buildAsync(
@@ -61,10 +67,10 @@ export class WorkflowCompilerTool extends ProjectTool {
         _cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
         if (!this.context) {
-            this.logger.warn(
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
                 "Pack operation requires a project operation context",
             );
-            return ToolResult.success();
         }
 
         return this.bundleExecutor.packAsync(options, this.context);