@uipath/packager-tool-workflowcompiler-browser 0.0.33 → 1.197.0-preview.64

package/src/project-bundle-executor.ts

@@ -62,9 +62,28 @@ export interface IProjectBundleExecutor {
  * 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,
@@ -416,6 +435,10 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
                 return {
                     RelativePath: project?.ProjectRelativePath ?? "",
                     DesignId: project?.Id ?? "",
+                    ProjectStorageId:
+                        entry.operation === BundleOperation.Pack
+                            ? (entry.options.projectStorageId ?? "")
+                            : "",
                     PackageId:
                         entry.operation === BundleOperation.Pack
                             ? entry.options.package.id
@@ -444,19 +467,60 @@ export class ProjectBundleExecutor implements IProjectBundleExecutor {
         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 body = {
+        const inputArguments = JSON.stringify(executorInfo);
+
+        const body: Record<string, unknown> = {
             source: "StudioWeb",
             targetFramework: context.targetFramework,
             jobType: "PublishStudioProject",
-            inputArguments: JSON.stringify(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}`,
@@ -484,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);