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

package/dist/pack-result-processor.d.ts

@@ -0,0 +1,17 @@
+import { type IFileSystem, type IProjectPackOptions, type IToolLogger, type IZipService, type ProjectOperationContext, ToolResult } from "@uipath/solutionpackager-tool-core";
+interface ProjectResultEntry {
+    options: IProjectPackOptions;
+}
+export declare class PackResultProcessor {
+    private readonly fileSystem;
+    private readonly logger?;
+    private readonly zipService;
+    constructor(fileSystem: IFileSystem, logger?: IToolLogger | undefined, zipService?: IZipService);
+    processAsync(bucketId: number, projects: Map<string, ProjectResultEntry>, context: ProjectOperationContext, archiveName?: string): Promise<Map<string, ToolResult>>;
+    private downloadArchiveAsync;
+    private deleteBucketAsync;
+    private getReadUriAsync;
+    private downloadBlobAsync;
+    private distributePackages;
+}
+export {};

package/dist/packager-hub-connection.d.ts

@@ -0,0 +1,37 @@
+import { type IToolLogger, type RemoteWorkflowCompilerCleanupPayload as RemoteProjectCleanup } from "@uipath/solutionpackager-tool-core";
+/** @public */
+export declare enum CompletedStatus {
+    Succeeded = 0,
+    Stopped = 1,
+    Failed = 2
+}
+export interface PackAgentResult {
+    errorCode: number;
+    status: CompletedStatus;
+    message?: string;
+    bucketId?: number;
+    /**
+     * Pack only: the archive's file name in the bucket. Agents that predate it
+     * do not send it; they upload `rpa-packages.zip`.
+     */
+    archiveName?: string;
+    /** Cleanup only: files changed per project design id, relative to each project. */
+    changedFilesByProject?: Record<string, string[]>;
+    /** Cleanup only: raw per-project cleanup payload, keyed by project design id. */
+    unusedDependenciesByProject?: Record<string, RemoteProjectCleanup>;
+}
+export declare class PackagerHubConnection {
+    private readonly logger?;
+    private hubConnection;
+    private completionResolve;
+    private completionReject;
+    constructor(logger?: IToolLogger | undefined);
+    connectAsync(hubUrl: string, accessToken: string): Promise<void>;
+    private buildConnection;
+    private registerOnClose;
+    waitForCompletionAsync(): Promise<PackAgentResult>;
+    disconnectAsync(): Promise<void>;
+    private registerHandlers;
+    private onLogMessage;
+    private onExecutionCompleted;
+}

package/dist/remote-agent-bundle-executor.d.ts

@@ -0,0 +1,103 @@
+import { type IFileSystem, type IProjectCleanupOptions, type IProjectPackOptions, type IProjectValidateOptions, type ProjectOperationContext, ToolResult } from "@uipath/solutionpackager-tool-core";
+import { BundleOperation } from "./bundle-operation.js";
+import { RemoteProjectSelector } from "./remote-project-selector.js";
+/**
+ * Hands one project to the remote agent. Every call for one operation context,
+ * whatever the project's type, joins the same bundle and so the same
+ * Orchestrator job.
+ */
+export interface IRemoteAgentBundleExecutor {
+    packAsync(options: IProjectPackOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    cleanupAsync(options: IProjectCleanupOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    /**
+     * Tells the bundle that a remote project's tool has nothing for the agent
+     * to do in `operation`, so the bundle stops waiting for it and leaves it
+     * out of the job. When every remote project is skipped, no job starts.
+     * Resolves once the skip is recorded, without waiting for the job.
+     */
+    skipAsync(operation: BundleOperation, projectPath: string, context: ProjectOperationContext): Promise<ToolResult>;
+}
+/**
+ * Coordinates one remote-agent run for every remote project of an operation
+ * context. Tools of any remote project type submit their project; once
+ * every project the context will send has arrived, the executor starts a
+ * single Orchestrator job for all of them and resolves each caller with its
+ * own result.
+ *
+ * Which projects to wait for comes from {@link RemoteProjectSelector}, so the
+ * bundle spans every remote factory that is actually registered, not just the
+ * one that created the tool.
+ */
+export declare class RemoteAgentBundleExecutor implements IRemoteAgentBundleExecutor {
+    private readonly fileSystem;
+    private readonly selector;
+    static readonly SESSION_TIMEOUT_MS = 1800000;
+    /**
+     * How long the agent job may stay Pending. A job no robot picks up would
+     * otherwise keep the operation waiting for a result that never comes.
+     */
+    static readonly JOB_START_TIMEOUT_MS = 300000;
+    static readonly JOB_POLL_INTERVAL_MS = 5000;
+    /**
+     * 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 = 10000;
+    private readonly sessions;
+    private readonly pendingSessionCreations;
+    constructor(fileSystem: IFileSystem, selector?: RemoteProjectSelector);
+    packAsync(options: IProjectPackOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    cleanupAsync(options: IProjectCleanupOptions, context: ProjectOperationContext): Promise<ToolResult>;
+    skipAsync(operation: BundleOperation, projectPath: string, context: ProjectOperationContext): Promise<ToolResult>;
+    private enqueueAsync;
+    /** Why `projectPath` may not join `session` for `operation`, if it may not. */
+    private checkJoin;
+    /**
+     * Once every remote project has been submitted or skipped, runs the job
+     * for the submitted ones, or closes the session when all were skipped.
+     */
+    private runIfCompleteAsync;
+    private getSessionAsync;
+    private createSessionAsync;
+    private runAgentAsync;
+    /**
+     * Rejects when the agent job is still Pending after
+     * {@link JOB_START_TIMEOUT_MS}, after asking Orchestrator to stop it so it
+     * cannot run later for a caller that has given up. Never resolves: once
+     * the job has started, or when it cannot be watched, the agent's own
+     * result (or the hub closing) settles the operation.
+     */
+    private failIfJobNeverStartsAsync;
+    private stopPendingJobAsync;
+    private connectToHubAsync;
+    private handleAgentResultAsync;
+    /**
+     * The agent removed unused items in-place and (for cloud solutions) saved the
+     * solution back to StudioWeb; there is no bucket to download. Resolve each
+     * project with its own result carrying the changed files (the full map, which
+     * solution-cleanup-service unions) and that project's cleanup payload mapped
+     * to the generic {@link toProjectCleanupInfo} shape.
+     */
+    private resolveCleanup;
+    private handlePackBucketAsync;
+    private sendBeginSessionAsync;
+    /**
+     * 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 uploadInputArgumentsFileAsync;
+    private resolveAll;
+}
+/**
+ * The bundle executor shared by every remote-agent tool factory in this
+ * runtime, created on first use with the file system of the first caller.
+ * Every factory must go through it for the RPA, Function and coded app
+ * projects of one pack to land in the same agent job.
+ */
+export declare function getSharedRemoteAgentBundleExecutor(fileSystem: IFileSystem): IRemoteAgentBundleExecutor;

package/dist/remote-agent-project-tool.d.ts

@@ -0,0 +1,41 @@
+import { type IFileSystem, type IProjectCleanupOptions, type IProjectPackOptions, type IProjectValidateOptions, type IToolLogger, type ProjectOperationContext, ProjectTool, type ProjectType, ToolResult } from "@uipath/solutionpackager-tool-core";
+import { type IRemoteAgentBundleExecutor } from "./remote-agent-bundle-executor.js";
+import type { IRemoteAgentToolFactory } from "./remote-project-selector.js";
+/**
+ * A browser tool whose projects only pack on the Remote Agent: pack goes to
+ * the shared bundle executor, while validate and cleanup have nothing for the
+ * agent to do and tell the bundle to skip the project, so the other projects'
+ * job no longer waits for it and no job starts when nothing else needs one.
+ * Restore and build keep the base no-ops.
+ *
+ * A subclass names the project id the package gets. The agent packs a
+ * throwaway copy of the project, so an id it minted there would change on
+ * every pack.
+ */
+export declare abstract class RemoteAgentProjectTool extends ProjectTool {
+    protected readonly bundleExecutor: IRemoteAgentBundleExecutor;
+    protected readonly context?: ProjectOperationContext | undefined;
+    constructor(fileSystem: IFileSystem, logger: IToolLogger, bundleExecutor: IRemoteAgentBundleExecutor, context?: ProjectOperationContext | undefined);
+    /** The project id the agent's package carries, sent as `ProjectStorageId`. */
+    protected abstract resolveProjectIdAsync(options: IProjectPackOptions): Promise<string>;
+    validateAsync(options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    cleanupAsync(options: IProjectCleanupOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+}
+/**
+ * Factory for a {@link RemoteAgentProjectTool}. Its tools use the given
+ * bundle executor, by default the one every remote factory shares, so all the
+ * remote projects of a pack land in one agent job.
+ */
+export declare abstract class RemoteAgentProjectToolFactory implements IRemoteAgentToolFactory {
+    private readonly bundleExecutor?;
+    readonly delegatesToRemoteAgent = true;
+    abstract readonly supportedTypes: readonly ProjectType[];
+    /**
+     * @param bundleExecutor Executor to delegate to; defaults to the shared
+     * one. Tests pass their own.
+     */
+    constructor(bundleExecutor?: IRemoteAgentBundleExecutor | undefined);
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem, context?: ProjectOperationContext): Promise<ProjectTool>;
+    protected abstract createTool(fileSystem: IFileSystem, logger: IToolLogger, bundleExecutor: IRemoteAgentBundleExecutor, context?: ProjectOperationContext): ProjectTool;
+}

package/dist/remote-project-selector.d.ts

@@ -0,0 +1,33 @@
+import { type IProjectToolFactory, type IToolsFactoryRepository, type ProjectType, type UiPathProject } from "@uipath/solutionpackager-tool-core";
+/**
+ * A project tool factory whose tools hand their projects to the shared
+ * remote-agent bundle executor. {@link RemoteProjectSelector} looks for this
+ * marker on the registered factories, so every factory that delegates to the
+ * executor must carry it.
+ */
+export interface IRemoteAgentToolFactory extends IProjectToolFactory {
+    readonly delegatesToRemoteAgent: true;
+}
+/**
+ * Decides which projects the remote agent processes: those whose type is
+ * packed by a tool that delegates to it.
+ *
+ * It asks the tools-factory registry — the same lookup the packager uses to
+ * dispatch each project — so a remote factory that lost its type to a local
+ * one (the first registration wins) never makes the bundle wait for a project
+ * that will not come.
+ */
+export declare class RemoteProjectSelector {
+    private readonly repository;
+    constructor(repository?: IToolsFactoryRepository);
+    /** Whether projects of `projectType` are processed by the remote agent. */
+    isRemote(projectType: ProjectType): boolean;
+    /** The projects of an operation that will join the remote-agent bundle. */
+    selectRemoteProjects(projects: readonly UiPathProject[]): UiPathProject[];
+    /**
+     * Read off the marker rather than a class: factories implement
+     * {@link IRemoteAgentToolFactory}, they do not extend anything `instanceof`
+     * could check.
+     */
+    private isRemoteAgentToolFactory;
+}

package/package.json

@@ -1,6 +1,28 @@
 {
-  "name": "@uipath/packager-remote-agent-browser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@uipath/packager-remote-agent-browser",
+    "version": "1.205.0-preview.258",
+    "description": "UiPath Remote Agent bundling for browser packager tools",
+    "type": "module",
+    "exports": {
+        ".": "./dist/index.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/cli.git",
+        "directory": "packages/packager/packager-remote-agent-browser"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "author": "UiPath",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "peerDependencies": {
+        "@uipath/solutionpackager-tool-core": "1.205.0",
+        "@microsoft/signalr": ">=7 <11"
+    },
+    "gitHead": "8f629ee9fa89abf94f197436a60cb3b9620f8b27"
+}