@uipath/packager-remote-agent-browser 0.0.0-stage → 1.205.0-preview.258

package/dist/index.js

@@ -0,0 +1,1523 @@
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  remoteAgentBrowser: {
+    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: "Eingabeargumente sind zu groß ({length} Zeichen), um sie inline zu senden; sie werden als Dateianhang hochgeladen"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Anhang für Eingabeargumente konnte nicht erstellt werden ({status}): {errorText}",
+      attachmentResponseMalformed: "Die Antwort auf die Anhangerstellung enthielt keine ID und keine Blob-URI",
+      uploadInputArgumentsFailed: "Datei mit Eingabeargumenten konnte nicht hochgeladen werden ({status}): {statusText}"
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  remoteAgentBrowser: {
+    info: {
+      startingRemoteAgent: "Starting remote {operation} 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)",
+      skippingRemoteCompilation: "No connection info available — skipping remote compilation for workflow compiler projects",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}",
+      offloadingInputArguments: "Input arguments are too large ({length} chars) to send inline; uploading them as a file attachment"
+    },
+    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",
+      agentFailed: "{operation} 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}",
+      downloadArchiveUnreachable: "Could not download the pack result from {host}: {message}. The agent finished; the browser could not reach the result storage, most often because it does not allow this page's origin (CORS).",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noPackageFromAgent: "The remote agent returned no package for {project} ({projectType}, design {designId}). An agent that does not pack {projectType} projects skips them.",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      jobStartTimeout: "The remote agent job {jobKey} was still pending after {minutes} minute(s): no robot picked it up, so it was stopped. Check that a robot or serverless capacity is available in the folder and retry.",
+      bundleOperationMismatch: "Cannot mix {sessionOperation} and {entryOperation} in the same context",
+      createAttachmentFailed: "Failed to create input arguments attachment ({status}): {errorText}",
+      attachmentResponseMalformed: "Attachment creation response did not include an id and blob URI",
+      uploadInputArgumentsFailed: "Failed to upload input arguments file ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  remoteAgentBrowser: {
+    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: "Los argumentos de entrada son demasiado grandes ({length} caracteres) para enviarlos en línea; se cargarán como un archivo adjunto"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "No se pudo crear el archivo adjunto de argumentos de entrada ({status}): {errorText}",
+      attachmentResponseMalformed: "La respuesta de creación del archivo adjunto no incluía un id ni un URI de blob",
+      uploadInputArgumentsFailed: "No se pudo cargar el archivo de argumentos de entrada ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  remoteAgentBrowser: {
+    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: "Los argumentos de entrada son demasiado grandes ({length} caracteres) para enviarlos en línea; se cargarán como un archivo adjunto"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "No se pudo crear el archivo adjunto de argumentos de entrada ({status}): {errorText}",
+      attachmentResponseMalformed: "La respuesta de creación del archivo adjunto no incluía un id ni un URI de blob",
+      uploadInputArgumentsFailed: "No se pudo cargar el archivo de argumentos de entrada ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  remoteAgentBrowser: {
+    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: "Les arguments d'entrée sont trop volumineux ({length} caractères) pour être envoyés en ligne ; ils seront chargés en tant que pièce jointe"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Échec de la création de la pièce jointe des arguments d'entrée ({status}) : {errorText}",
+      attachmentResponseMalformed: "La réponse de création de la pièce jointe ne contenait pas d'id ni d'URI de blob",
+      uploadInputArgumentsFailed: "Échec du chargement du fichier des arguments d'entrée ({status}) : {statusText}"
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  remoteAgentBrowser: {
+    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: "Os argumentos de entrada são demasiado grandes ({length} carateres) para serem enviados inline; serão carregados como um anexo de ficheiro"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Falha ao criar o anexo dos argumentos de entrada ({status}): {errorText}",
+      attachmentResponseMalformed: "A resposta de criação do anexo não incluía um id nem um URI de blob",
+      uploadInputArgumentsFailed: "Falha ao carregar o ficheiro de argumentos de entrada ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  remoteAgentBrowser: {
+    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: "Os argumentos de entrada são muito grandes ({length} caracteres) para serem enviados inline; eles serão carregados como um anexo de arquivo"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Falha ao criar o anexo dos argumentos de entrada ({status}): {errorText}",
+      attachmentResponseMalformed: "A resposta de criação do anexo não incluiu um id nem uma URI de blob",
+      uploadInputArgumentsFailed: "Falha ao fazer upload do arquivo de argumentos de entrada ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  remoteAgentBrowser: {
+    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: "Argumentele de intrare sunt prea mari ({length} caractere) pentru a fi trimise inline; vor fi încărcate ca atașament de fișier"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Crearea atașamentului cu argumentele de intrare a eșuat ({status}): {errorText}",
+      attachmentResponseMalformed: "Răspunsul de creare a atașamentului nu a inclus un id și un URI de blob",
+      uploadInputArgumentsFailed: "Încărcarea fișierului cu argumentele de intrare a eșuat ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  remoteAgentBrowser: {
+    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: "Giriş bağımsız değişkenleri satır içi gönderilemeyecek kadar büyük ({length} karakter); dosya eki olarak yüklenecek"
+    },
+    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}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects",
+      createAttachmentFailed: "Giriş bağımsız değişkenleri eki oluşturulamadı ({status}): {errorText}",
+      attachmentResponseMalformed: "Ek oluşturma yanıtı bir kimlik ve blob URI'si içermiyordu",
+      uploadInputArgumentsFailed: "Giriş bağımsız değişkenleri dosyası yüklenemedi ({status}): {statusText}"
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  remoteAgentBrowser: {
+    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}",
+      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}"
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// src/bundle-operation.ts
+var BundleOperation;
+((BundleOperation2) => {
+  BundleOperation2["Pack"] = "Pack";
+  BundleOperation2["Validate"] = "Validate";
+  BundleOperation2["Cleanup"] = "Cleanup";
+})(BundleOperation ||= {});
+// src/remote-agent-bundle-executor.ts
+import {
+  normalizeIgnoredRules,
+  PackJobTargetKind,
+  ProjectTypes,
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2,
+  toProjectCleanupInfoFromRemote,
+  toRelativeUrl as toRelativeUrl2,
+  translate as translate3
+} from "@uipath/solutionpackager-tool-core";
+
+// src/pack-result-processor.ts
+import {
+  ToolErrorCodes,
+  ToolResult,
+  toRelativeUrl,
+  translate,
+  ZipService
+} from "@uipath/solutionpackager-tool-core";
+var DefaultArchiveName = "rpa-packages.zip";
+
+class PackResultProcessor {
+  fileSystem;
+  logger;
+  zipService;
+  constructor(fileSystem, logger, zipService = new ZipService(fileSystem)) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+    this.zipService = zipService;
+  }
+  async processAsync(bucketId, projects, context, archiveName) {
+    const connection = context.connection;
+    const results = new Map;
+    const tempDir = await this.fileSystem.getTempDir();
+    const extractPath = `${tempDir}/pack-result-${context.id}`;
+    try {
+      this.logger?.info(translate.t("remoteAgentBrowser.info.downloadingArchive", {
+        bucketId
+      }));
+      const zipData = await this.downloadArchiveAsync(bucketId, archiveName || DefaultArchiveName, connection);
+      this.logger?.info(translate.t("remoteAgentBrowser.info.extractingArchive", {
+        size: zipData.length,
+        path: extractPath
+      }));
+      await this.zipService.extractAsync(zipData, extractPath);
+      this.logger?.info(translate.t("remoteAgentBrowser.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("remoteAgentBrowser.info.cleaningUpTempDir", {
+        path: extractPath
+      }));
+      await this.fileSystem.rm(extractPath).catch(() => {});
+      await this.deleteBucketAsync(bucketId, connection);
+    }
+    return results;
+  }
+  async downloadArchiveAsync(bucketId, archiveName, connection) {
+    const blobAccess = await this.getReadUriAsync(bucketId, archiveName, connection);
+    return await this.downloadBlobAsync(blobAccess);
+  }
+  async deleteBucketAsync(bucketId, connection) {
+    try {
+      if (!bucketId) {
+        return;
+      }
+      const baseUrl = toRelativeUrl(connection.cloudUrl);
+      const url = `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})`;
+      this.logger?.info(translate.t("remoteAgentBrowser.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("remoteAgentBrowser.errors.deleteBucketFailed", { statusText: response.statusText }));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.warn(translate.t("remoteAgentBrowser.errors.cleanupBucketFailed", {
+        bucketId,
+        message
+      }));
+    }
+  }
+  async getReadUriAsync(bucketId, archiveName, connection) {
+    const baseUrl = toRelativeUrl(connection.cloudUrl);
+    const url = `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})` + `/UiPath.Server.Configuration.OData.GetReadUri` + `?path=${encodeURIComponent(archiveName)}&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("remoteAgentBrowser.errors.getBucketUriFailed", {
+        status: response.status,
+        errorText
+      }));
+    }
+    return await response.json();
+  }
+  async downloadBlobAsync(blobAccess) {
+    const headers = {};
+    if (blobAccess.Headers) {
+      for (const [key, value] of Object.entries(blobAccess.Headers)) {
+        headers[key] = value;
+      }
+    }
+    let response;
+    try {
+      response = await fetch(blobAccess.Uri, {
+        method: blobAccess.Verb || "GET",
+        headers
+      });
+    } catch (error) {
+      throw new Error(translate.t("remoteAgentBrowser.errors.downloadArchiveUnreachable", {
+        host: hostOf(blobAccess.Uri),
+        message: error instanceof Error ? error.message : String(error)
+      }));
+    }
+    if (!response.ok) {
+      throw new Error(translate.t("remoteAgentBrowser.errors.downloadArchiveFailed", {
+        status: response.status,
+        statusText: response.statusText
+      }));
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async distributePackages(extractPath, projects, context, results) {
+    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("remoteAgentBrowser.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("remoteAgentBrowser.errors.noPackageFromAgent", {
+            project: project.ProjectRelativePath,
+            projectType: project.Type,
+            designId
+          })));
+          continue;
+        }
+        const files = await this.fileSystem.readdir(projectFilesDir);
+        const outputFiles = [];
+        await this.fileSystem.mkdir(outputPath);
+        this.logger?.info(translate.t("remoteAgentBrowser.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("remoteAgentBrowser.errors.distributePackagesFailed", { designId, message })));
+      }
+    }
+  }
+}
+function hostOf(uri) {
+  try {
+    return new URL(uri).host;
+  } catch {
+    return uri;
+  }
+}
+
+// src/packager-hub-connection.ts
+import {
+  HttpTransportType,
+  HubConnectionBuilder,
+  HubConnectionState
+} from "@microsoft/signalr";
+import {
+  LogMessage,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+class PackagerHubConnection {
+  logger;
+  hubConnection = null;
+  completionResolve = null;
+  completionReject = null;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async connectAsync(hubUrl, accessToken) {
+    try {
+      this.hubConnection = this.buildConnection(hubUrl, accessToken);
+      this.registerHandlers();
+      this.registerOnClose();
+      await this.hubConnection.start();
+    } catch (error) {
+      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;
+      }
+    }
+  }
+  buildConnection(hubUrl, accessToken, disableWs = false) {
+    return new HubConnectionBuilder().withUrl(hubUrl, {
+      accessTokenFactory: () => accessToken,
+      transport: disableWs ? HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling : undefined
+    }).withAutomaticReconnect().build();
+  }
+  registerOnClose() {
+    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(translate2.t("remoteAgentBrowser.errors.hubConnectionClosed")));
+        this.completionResolve = null;
+        this.completionReject = null;
+      }
+    });
+  }
+  waitForCompletionAsync() {
+    return new Promise((resolve, reject) => {
+      this.completionResolve = resolve;
+      this.completionReject = reject;
+    });
+  }
+  async disconnectAsync() {
+    if (this.hubConnection && this.hubConnection.state !== HubConnectionState.Disconnected) {
+      await this.hubConnection.stop();
+    }
+    this.hubConnection = null;
+  }
+  registerHandlers() {
+    if (!this.hubConnection)
+      return;
+    this.hubConnection.on("SetExecutionCompleted" /* SetExecutionCompleted */, (jsonCommand) => {
+      this.onExecutionCompleted(jsonCommand);
+    });
+    this.hubConnection.on("SetLogMessage" /* SetLogMessage */, (jsonCommand) => {
+      this.onLogMessage(jsonCommand);
+    });
+    this.hubConnection.on("SetExecutionStarted" /* SetExecutionStarted */, (_jsonCommand) => {
+      this.logger?.info(translate2.t("remoteAgentBrowser.info.remoteAgentStartedExecution"));
+    });
+    this.hubConnection.on("PeerDisconnected" /* PeerDisconnected */, () => {
+      this.logger?.info(`[PackagerHub] PeerDisconnected received. hasReject=${!!this.completionReject}`);
+      if (this.completionReject) {
+        this.completionReject(new Error(translate2.t("remoteAgentBrowser.errors.packAgentDisconnected")));
+        this.completionResolve = null;
+        this.completionReject = null;
+      }
+    });
+  }
+  onLogMessage(jsonCommand) {
+    if (!this.logger)
+      return;
+    const command = 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);
+  }
+  onExecutionCompleted(jsonCommand) {
+    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 = 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}, archiveName=${jobResult.ArchiveName}`);
+    this.completionResolve({
+      errorCode: jobResult.ErrorCode,
+      status: jobResult.Status,
+      message: jobResult.Message,
+      bucketId: jobResult.BucketId,
+      archiveName: jobResult.ArchiveName,
+      changedFilesByProject: jobResult.ChangedFilesByProject,
+      unusedDependenciesByProject: jobResult.UnusedDependenciesByProject
+    });
+    this.completionResolve = null;
+    this.completionReject = null;
+  }
+}
+
+// src/remote-project-selector.ts
+import {
+  toolsFactoryRepository
+} from "@uipath/solutionpackager-tool-core";
+
+class RemoteProjectSelector {
+  repository;
+  constructor(repository = toolsFactoryRepository) {
+    this.repository = repository;
+  }
+  isRemote(projectType) {
+    return this.repository.canHandleProject(projectType) && this.isRemoteAgentToolFactory(this.repository.getProjectToolFactory(projectType));
+  }
+  selectRemoteProjects(projects) {
+    return projects.filter((p) => p.ProjectPath != null && this.isRemote(p.Type));
+  }
+  isRemoteAgentToolFactory(factory) {
+    return factory.delegatesToRemoteAgent === true;
+  }
+}
+
+// src/remote-agent-bundle-executor.ts
+class RemoteAgentBundleExecutor {
+  fileSystem;
+  selector;
+  static SESSION_TIMEOUT_MS = 1800000;
+  static JOB_START_TIMEOUT_MS = 300000;
+  static JOB_POLL_INTERVAL_MS = 5000;
+  static MAX_INLINE_INPUT_ARGUMENTS_LENGTH = 1e4;
+  sessions = new Map;
+  pendingSessionCreations = new Map;
+  constructor(fileSystem, selector = new RemoteProjectSelector) {
+    this.fileSystem = fileSystem;
+    this.selector = selector;
+  }
+  async packAsync(options, context) {
+    return this.enqueueAsync(context, options.projectPath, {
+      operation: "Pack" /* Pack */,
+      options,
+      resolve: () => {}
+    });
+  }
+  async validateAsync(options, context) {
+    return this.enqueueAsync(context, options.projectPath, {
+      operation: "Validate" /* Validate */,
+      options,
+      resolve: () => {}
+    });
+  }
+  async cleanupAsync(options, context) {
+    if (context.downloadUrl && !options.dryRun && !context.solutionId && !context.projectId) {
+      return ToolResult2.error(ToolErrorCodes2.InternalError, "Cleanup save-back requires a solutionId or projectId for downloaded workspaces.");
+    }
+    return this.enqueueAsync(context, options.projectPath, {
+      operation: "Cleanup" /* Cleanup */,
+      options,
+      resolve: () => {}
+    });
+  }
+  async skipAsync(operation, projectPath, context) {
+    context.logger?.info(`[BundleExecutor] ${operation} skipped for project: ${projectPath}`);
+    const session = await this.getSessionAsync(context, operation);
+    const rejection = this.checkJoin(session, operation, projectPath);
+    if (rejection) {
+      return rejection;
+    }
+    session.skipped.add(projectPath);
+    this.runIfCompleteAsync(session, context);
+    return ToolResult2.success();
+  }
+  async enqueueAsync(context, projectPath, entry) {
+    context.logger?.info(`[BundleExecutor] ${entry.operation}Async called for project: ${projectPath}`);
+    const session = await this.getSessionAsync(context, entry.operation);
+    const rejection = this.checkJoin(session, entry.operation, projectPath);
+    if (rejection) {
+      return rejection;
+    }
+    const promise = new Promise((resolve) => {
+      entry.resolve = resolve;
+    });
+    session.entries.set(projectPath, entry);
+    await this.runIfCompleteAsync(session, context);
+    return promise;
+  }
+  checkJoin(session, operation, projectPath) {
+    if (session.operation !== operation) {
+      return ToolResult2.error("BundleOperationMismatch", translate3.t("remoteAgentBrowser.errors.bundleOperationMismatch", {
+        sessionOperation: session.operation,
+        entryOperation: operation
+      }));
+    }
+    if (!session.remoteProjects.some((p) => p.ProjectPath === projectPath)) {
+      return ToolResult2.error("PackResultError", translate3.t("remoteAgentBrowser.errors.noMatchingProject", {
+        projectPath
+      }));
+    }
+    return;
+  }
+  async runIfCompleteAsync(session, context) {
+    const received = receivedCount(session);
+    const expected = session.remoteProjects.length;
+    context.logger?.info(`[BundleExecutor] session (${session.operation}): ${received}/${expected} projects received (${session.skipped.size} skipped).`);
+    if (received < expected) {
+      return;
+    }
+    clearTimeout(session.timeout);
+    if (session.entries.size > 0) {
+      await this.runAgentAsync(session, context);
+    }
+    this.sessions.delete(context.id);
+  }
+  getSessionAsync(context, operation) {
+    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, operation);
+      this.pendingSessionCreations.set(context.id, pending);
+    }
+    return pending;
+  }
+  async createSessionAsync(context, operation) {
+    const session = {
+      operation,
+      remoteProjects: this.selector.selectRemoteProjects(context.projects),
+      entries: new Map,
+      skipped: new Set
+    };
+    session.timeout = setTimeout(() => {
+      if (receivedCount(session) < session.remoteProjects.length) {
+        context.logger?.error(`[BundleExecutor] Session timed out after ${RemoteAgentBundleExecutor.SESSION_TIMEOUT_MS}ms: ` + `received ${receivedCount(session)}/${session.remoteProjects.length} projects`);
+        this.resolveAll(session, ToolResult2.error("SessionTimeoutError", translate3.t("remoteAgentBrowser.errors.sessionTimeout", {
+          received: receivedCount(session),
+          expected: session.remoteProjects.length
+        })));
+        this.sessions.delete(context.id);
+      }
+    }, RemoteAgentBundleExecutor.SESSION_TIMEOUT_MS);
+    this.sessions.set(context.id, session);
+    this.pendingSessionCreations.delete(context.id);
+    return session;
+  }
+  async runAgentAsync(session, context) {
+    context.logger?.info(translate3.t("remoteAgentBrowser.info.startingRemoteAgent", {
+      operation: session.operation,
+      count: session.entries.size,
+      paths: [...session.entries.keys()].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, ToolResult2.error("ConnectionError", translate3.t("remoteAgentBrowser.errors.missingConnectionInfo")));
+      return;
+    }
+    const sessionId = crypto.randomUUID();
+    const hubConnection = await this.connectToHubAsync(connection, sessionId, context.logger);
+    if (!hubConnection) {
+      this.resolveAll(session, ToolResult2.error("SignalRConnectionError", translate3.t("remoteAgentBrowser.errors.signalRConnectionFailed")));
+      return;
+    }
+    const stopWatching = new AbortController;
+    try {
+      context.logger?.info(`[BundleExecutor] Sending BeginSession...`);
+      const jobKey = await this.sendBeginSessionAsync(session, context, connection, sessionId);
+      context.logger?.info(`[BundleExecutor] BeginSession succeeded (job ${jobKey ?? "key not returned"}). Waiting for completion...`);
+      const result = await Promise.race([
+        hubConnection.waitForCompletionAsync(),
+        this.failIfJobNeverStartsAsync(jobKey, `${toRelativeUrl2(connection.cloudUrl)}/orchestrator_`, connection, context.logger, stopWatching.signal)
+      ]);
+      context.logger?.info(`[BundleExecutor] Got result: errorCode=${result.errorCode}, status=${result.status}, message=${result.message}, bucketId=${result.bucketId}`);
+      await this.handleAgentResultAsync(result, session, context);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      context.logger?.error(`[BundleExecutor] runAgentAsync caught error: ${message}`);
+      this.resolveAll(session, ToolResult2.error(`${session.operation}AgentError`, message));
+    } finally {
+      stopWatching.abort();
+      await hubConnection.disconnectAsync();
+    }
+  }
+  async failIfJobNeverStartsAsync(jobKey, orchestratorUrl, connection, logger, signal) {
+    const never = new Promise(() => {});
+    if (!jobKey) {
+      logger?.warn("[BundleExecutor] No job key returned; the job start is not watched.");
+      return never;
+    }
+    const url = `${orchestratorUrl}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${jobKey})`;
+    const headers = orchestratorHeaders(connection);
+    const deadline = Date.now() + RemoteAgentBundleExecutor.JOB_START_TIMEOUT_MS;
+    let job;
+    while (Date.now() < deadline) {
+      await delayAsync(RemoteAgentBundleExecutor.JOB_POLL_INTERVAL_MS, signal);
+      if (signal.aborted)
+        return never;
+      let response;
+      try {
+        response = await fetch(url, { headers, signal });
+      } catch {
+        if (signal.aborted)
+          return never;
+        continue;
+      }
+      if (response.status >= 500) {
+        continue;
+      }
+      if (!response.ok) {
+        logger?.warn(`[BundleExecutor] Cannot watch job ${jobKey} (HTTP ${response.status}); its start is not watched.`);
+        return never;
+      }
+      job = await response.json().catch(() => {
+        return;
+      });
+      if (job?.State && job.State !== "Pending") {
+        logger?.info(`[BundleExecutor] Job ${jobKey} left Pending: ${job.State}`);
+        return never;
+      }
+    }
+    await this.stopPendingJobAsync(job?.Id, jobKey, orchestratorUrl, connection, logger);
+    throw new Error(translate3.t("remoteAgentBrowser.errors.jobStartTimeout", {
+      jobKey,
+      minutes: RemoteAgentBundleExecutor.JOB_START_TIMEOUT_MS / 60000
+    }));
+  }
+  async stopPendingJobAsync(jobId, jobKey, orchestratorUrl, connection, logger) {
+    if (jobId === undefined) {
+      logger?.warn(`[BundleExecutor] Job ${jobKey} has no known id; it was not stopped.`);
+      return;
+    }
+    const url = `${orchestratorUrl}/odata/Jobs(${jobId})/UiPath.Server.Configuration.OData.StopJob`;
+    let problem;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...orchestratorHeaders(connection),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ strategy: "SoftStop" })
+      });
+      problem = response.ok ? undefined : `HTTP ${response.status}`;
+    } catch (error) {
+      problem = error instanceof Error ? error.message : String(error);
+    }
+    if (problem) {
+      logger?.warn(`[BundleExecutor] Could not stop pending job ${jobKey}: ${problem}`);
+    }
+  }
+  async connectToHubAsync(connection, sessionId, logger) {
+    const relativeBase = toRelativeUrl2(connection.cloudUrl);
+    const hubUrl = `${relativeBase}/orchestrator_/signalr/robotdebug?sessionId=${sessionId}`;
+    logger?.info(translate3.t("remoteAgentBrowser.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(translate3.t("remoteAgentBrowser.errors.hubConnectionFailed", {
+        url: hubUrl,
+        message
+      }));
+      return null;
+    }
+  }
+  async handleAgentResultAsync(result, session, context) {
+    if (result.errorCode !== 0 || result.status !== 0 /* Succeeded */) {
+      this.resolveAll(session, ToolResult2.error(`${session.operation}AgentError`, result.message ?? translate3.t("remoteAgentBrowser.errors.agentFailed", {
+        operation: session.operation,
+        status: result.status,
+        errorCode: result.errorCode
+      })));
+      return;
+    }
+    if (session.operation === "Pack" /* Pack */) {
+      await this.handlePackBucketAsync(result, session, context);
+      return;
+    }
+    if (session.operation === "Cleanup" /* Cleanup */) {
+      this.resolveCleanup(result, session);
+      return;
+    }
+    this.resolveAll(session, ToolResult2.success());
+  }
+  resolveCleanup(result, session) {
+    for (const { project, entry } of sessionProjects(session)) {
+      const details = {};
+      if (result.changedFilesByProject) {
+        details.changedFilesByProject = result.changedFilesByProject;
+      }
+      const raw = result.unusedDependenciesByProject?.[project.Id];
+      if (raw) {
+        details.projectCleanup = toProjectCleanupInfoFromRemote(raw);
+      }
+      const projectResult = ToolResult2.success();
+      if (Object.keys(details).length > 0) {
+        projectResult.details = details;
+      }
+      entry.resolve(projectResult);
+    }
+  }
+  async handlePackBucketAsync(result, session, context) {
+    if (result.bucketId == null) {
+      this.resolveAll(session, ToolResult2.error("PackAgentError", translate3.t("remoteAgentBrowser.errors.packSucceededNoBucket")));
+      return;
+    }
+    const packEntries = new Map;
+    for (const [projectPath, entry] of session.entries) {
+      if (entry.operation === "Pack" /* Pack */) {
+        packEntries.set(projectPath, { options: entry.options });
+      }
+    }
+    const resultProcessor = new PackResultProcessor(this.fileSystem, context.logger);
+    const perProjectResults = await resultProcessor.processAsync(result.bucketId, packEntries, context, result.archiveName);
+    for (const [projectPath, entry] of session.entries) {
+      const projectResult = perProjectResults.get(projectPath);
+      entry.resolve(projectResult ?? ToolResult2.error("PackResultError", translate3.t("remoteAgentBrowser.errors.noResultForProject")));
+    }
+  }
+  async sendBeginSessionAsync(session, context, connection, sessionId) {
+    const relativeBase = toRelativeUrl2(connection.cloudUrl);
+    const onLocalRobot = context.jobTarget?.kind === PackJobTargetKind.LocalRobot;
+    const url = onLocalRobot ? `${relativeBase}/orchestrator_/api/RobotDebug/BeginSession` : `${relativeBase}/orchestrator_/api/serverless/jobs`;
+    context.logger?.info(`[BundleExecutor] BeginSession URL: ${url} (target=${context.jobTarget?.kind ?? PackJobTargetKind.Serverless})`);
+    const entries = sessionProjects(session);
+    const firstEntry = entries[0].entry;
+    const opts = firstEntry.options;
+    const skipAnalyze = "skipAnalyze" in opts ? opts.skipAnalyze : false;
+    const skipValidate = "skipValidate" in opts ? opts.skipValidate : false;
+    const ignoredRules = normalizeIgnoredRules("ignoredRules" in opts ? opts.ignoredRules : undefined);
+    const executorInfo = {
+      Command: session.operation,
+      SupportedProtocolVersions: [PROTOCOL_VERSION],
+      DownloadUrl: context.downloadUrl ?? "",
+      SolutionId: context.solutionId ?? "",
+      ProjectId: context.projectId ?? "",
+      SessionId: sessionId,
+      ProfileKey: "StudioWeb",
+      LicenseType: "Development",
+      LogLevel: opts.logLevel ?? "Warning",
+      Culture: "en-US",
+      DownloadTimeoutInSeconds: 300,
+      SkipAnalyze: String(skipAnalyze),
+      SkipValidate: String(skipValidate),
+      TargetFramework: context.targetFramework
+    };
+    if (ignoredRules.length > 0) {
+      executorInfo.IgnoredRules = ignoredRules;
+    }
+    const rpaProjects = entries.filter((p) => !isFunctionProject(p) && !isCodedAppProject(p));
+    if (rpaProjects.length > 0) {
+      executorInfo.RpaProjects = rpaProjects.map(toProjectPayload);
+      executorInfo.WorkflowCompilerVersion = context.workflowCompilerVersion ?? "";
+    }
+    const functionProjects = entries.filter(isFunctionProject);
+    if (functionProjects.length > 0) {
+      executorInfo.FunctionProjects = functionProjects.map(toProjectPayload);
+      executorInfo.FunctionsPackagerVersion = context.functionsPackagerVersion ?? "";
+    }
+    const codedAppProjects = entries.filter(isCodedAppProject);
+    if (codedAppProjects.length > 0) {
+      executorInfo.CodedAppProjects = codedAppProjects.map(toProjectPayload);
+      executorInfo.CodedAppsPackagerVersion = context.codedAppsPackagerVersion ?? "";
+    }
+    if (firstEntry.operation === "Pack" /* 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 ?? ""
+      };
+      executorInfo.Name = pkg.id;
+      executorInfo.Version = pkg.version;
+      executorInfo.Author = pkg.author ?? "";
+      executorInfo.Description = pkg.description ?? "";
+      executorInfo.ReleaseNotes = pkg.releaseNotes ?? "";
+      if (context.localSourcePath) {
+        if (onLocalRobot && context.jobTarget?.machineSessionIds?.length) {
+          executorInfo.LocalSourcePath = context.localSourcePath;
+        } else {
+          context.logger?.warn("[BundleExecutor] Dropping localSourcePath: the pack job is not pinned to a local robot machine session.");
+        }
+      }
+    }
+    if (firstEntry.operation === "Cleanup" /* Cleanup */) {
+      executorInfo.DryRun = firstEntry.options.dryRun;
+      executorInfo.SkipImports = firstEntry.options.skipImports;
+      if (context.lockKey) {
+        executorInfo.LockKey = context.lockKey;
+      }
+    }
+    const inputArguments = JSON.stringify(executorInfo);
+    const body = onLocalRobot ? {
+      source: "StudioWeb",
+      targetFramework: context.targetFramework,
+      runtimeType: "Development",
+      runAsMe: true,
+      jobsCount: 1,
+      strategy: "ModernJobsCount",
+      requiresUserInteraction: false,
+      ...context.jobTarget?.machineSessionIds?.length ? {
+        machineSessionIds: context.jobTarget.machineSessionIds
+      } : {}
+    } : {
+      source: "StudioWeb",
+      targetFramework: context.targetFramework,
+      jobType: "PublishStudioProject"
+    };
+    if (inputArguments.length > RemoteAgentBundleExecutor.MAX_INLINE_INPUT_ARGUMENTS_LENGTH) {
+      context.logger?.info(translate3.t("remoteAgentBrowser.info.offloadingInputArguments", { length: inputArguments.length }));
+      body.inputFile = await this.uploadInputArgumentsFileAsync(inputArguments, connection, context.logger);
+    } else {
+      body.inputArguments = inputArguments;
+    }
+    const headers = {
+      "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(translate3.t("remoteAgentBrowser.errors.beginSessionFailed", {
+        status: response.status,
+        errorText
+      }));
+    }
+    const created = await response.json().catch(() => {
+      return;
+    });
+    return created?.jobKey || created?.key || undefined;
+  }
+  async uploadInputArgumentsFileAsync(inputArguments, connection, logger) {
+    const baseUrl = toRelativeUrl2(connection.cloudUrl);
+    const attachmentsUrl = `${baseUrl}/orchestrator_/odata/Attachments`;
+    const headers = {
+      "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(translate3.t("remoteAgentBrowser.errors.createAttachmentFailed", { status: createResponse.status, errorText }));
+    }
+    const attachment = await createResponse.json();
+    const attachmentId = attachment.Id ?? attachment.id ?? "";
+    const writeUri = attachment.BlobFileAccess?.Uri ?? attachment.blobFileAccess?.Uri;
+    if (!attachmentId || !writeUri) {
+      throw new Error(translate3.t("remoteAgentBrowser.errors.attachmentResponseMalformed"));
+    }
+    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(translate3.t("remoteAgentBrowser.errors.uploadInputArgumentsFailed", {
+        status: uploadResponse.status,
+        statusText: uploadResponse.statusText
+      }));
+    }
+    logger?.info(`[BundleExecutor] Uploaded input arguments as attachment ${attachmentId}`);
+    return attachmentId;
+  }
+  resolveAll(session, result) {
+    for (const [, entry] of session.entries) {
+      entry.resolve(result);
+    }
+  }
+}
+function orchestratorHeaders(connection) {
+  const headers = {
+    Authorization: `Bearer ${connection.accessToken}`,
+    "X-UIPATH-OrganizationUnitId": connection.folderId ?? ""
+  };
+  if (connection.tenantId) {
+    headers["x-uipath-tenantid"] = connection.tenantId;
+  }
+  return headers;
+}
+function delayAsync(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+function receivedCount(session) {
+  return session.entries.size + session.skipped.size;
+}
+function sessionProjects(session) {
+  return session.remoteProjects.flatMap((project) => {
+    const entry = project.ProjectPath != null ? session.entries.get(project.ProjectPath) : undefined;
+    return entry ? [{ project, entry }] : [];
+  });
+}
+function toProjectPayload({
+  project,
+  entry
+}) {
+  const packing = entry.operation === "Pack" /* Pack */;
+  return {
+    RelativePath: project.ProjectRelativePath,
+    DesignId: project.Id,
+    ProjectStorageId: packing ? entry.options.projectStorageId ?? "" : "",
+    PackageId: packing ? entry.options.package.id : ""
+  };
+}
+function isFunctionProject({ project }) {
+  return project.Type === ProjectTypes.Function;
+}
+function isCodedAppProject({ project }) {
+  return project.Type === ProjectTypes.AppV2;
+}
+var PROTOCOL_VERSION = "2.0";
+var SHARED_EXECUTOR_KEY = Symbol.for("@uipath/packager-remote-agent-browser/bundleExecutor");
+function getSharedRemoteAgentBundleExecutor(fileSystem) {
+  const global = globalThis;
+  const existing = global[SHARED_EXECUTOR_KEY];
+  if (isBundleExecutor(existing)) {
+    return existing;
+  }
+  const executor = new RemoteAgentBundleExecutor(fileSystem);
+  global[SHARED_EXECUTOR_KEY] = executor;
+  return executor;
+}
+function isBundleExecutor(value) {
+  const candidate = value;
+  return typeof candidate?.packAsync === "function" && typeof candidate.validateAsync === "function" && typeof candidate.cleanupAsync === "function" && typeof candidate.skipAsync === "function";
+}
+// src/remote-agent-project-tool.ts
+import {
+  ProjectTool,
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3
+} from "@uipath/solutionpackager-tool-core";
+class RemoteAgentProjectTool extends ProjectTool {
+  bundleExecutor;
+  context;
+  constructor(fileSystem, logger, bundleExecutor, context) {
+    super(fileSystem, logger);
+    this.bundleExecutor = bundleExecutor;
+    this.context = context;
+  }
+  async validateAsync(options, _cancellationToken) {
+    if (!this.context) {
+      return missingContext("Validate");
+    }
+    return this.bundleExecutor.skipAsync("Validate" /* Validate */, options.projectPath, this.context);
+  }
+  async packAsync(options, _cancellationToken) {
+    if (!this.context) {
+      return missingContext("Pack");
+    }
+    let projectStorageId;
+    try {
+      projectStorageId = await this.resolveProjectIdAsync(options);
+    } catch (error) {
+      await this.bundleExecutor.skipAsync("Pack" /* Pack */, options.projectPath, this.context);
+      return ToolResult3.error(ToolErrorCodes3.InternalError, error instanceof Error ? error.message : String(error));
+    }
+    return this.bundleExecutor.packAsync({ ...options, projectStorageId }, this.context);
+  }
+  async cleanupAsync(options, _cancellationToken) {
+    if (!this.context) {
+      return missingContext("Cleanup");
+    }
+    return this.bundleExecutor.skipAsync("Cleanup" /* Cleanup */, options.projectPath, this.context);
+  }
+}
+
+class RemoteAgentProjectToolFactory {
+  bundleExecutor;
+  delegatesToRemoteAgent = true;
+  constructor(bundleExecutor) {
+    this.bundleExecutor = bundleExecutor;
+  }
+  async createAsync(logger, fileSystem, context) {
+    return this.createTool(fileSystem, logger, this.bundleExecutor ?? getSharedRemoteAgentBundleExecutor(fileSystem), context);
+  }
+}
+function missingContext(operation) {
+  return ToolResult3.error(ToolErrorCodes3.InternalError, `${operation} operation requires a project operation context`);
+}
+export {
+  BundleOperation,
+  RemoteAgentProjectTool,
+  RemoteAgentProjectToolFactory,
+  getSharedRemoteAgentBundleExecutor
+};
+
+//# debugId=48A0D895188D012364756E2164756E21