@uipath/project-packager 1.1.10 → 1.196.0

package/dist/src/base-browser-packager-factory.d.ts

@@ -0,0 +1,37 @@
+import { type ITelemetryService } from "@uipath/common/telemetry";
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { PackagerConfig } from "./models/packager-config.js";
+/**
+ * Base factory class containing common functionality for browser packager factories.
+ *
+ * Mirrors {@link BaseNodePackagerFactory} on the browser side: shared
+ * filesystem + telemetry defaults, log-handler wiring, and locale config.
+ * Subclasses (`BrowserProjectPackagerFactory`, `BrowserSolutionPackagerFactory`)
+ * compose these to build their respective packager instances.
+ */
+export declare abstract class BaseBrowserPackagerFactory {
+    /**
+     * Returns the provided file system or the shared {@link BrowserFileSystem}
+     * singleton, creating + initializing it on first call. The singleton is
+     * shared across browser factories so files written by one are visible to
+     * the others.
+     * @param config - Configuration options containing optional file system
+     */
+    protected getOrCreateFileSystem(config?: PackagerConfig): Promise<IFileSystem>;
+    /**
+     * Returns the provided telemetry service or creates a default one
+     * (`ConsoleTelemetryProvider` + `BrowserContextStorage`).
+     * @param config - Configuration options containing optional telemetry service
+     */
+    protected getOrCreateTelemetryService(config?: PackagerConfig): ITelemetryService;
+    /**
+     * Configures the global log handler if provided in config.
+     * @param config - Configuration options containing optional log handler
+     */
+    protected configureLogHandler(config?: PackagerConfig): void;
+    /**
+     * Configures the translation locale.
+     * @param config - Configuration options containing optional language
+     */
+    protected configureLanguage(config?: PackagerConfig): void;
+}

package/dist/src/base-node-packager-factory.d.ts

@@ -1,10 +1,16 @@
+import { type ITelemetryService } from "@uipath/common";
 import type { IFileSystem, IToolLogger } from "@uipath/solutionpackager-tool-core";
-import { type ITelemetryService } from "@uipath/telemetry/node";
 import type { PackagerConfig } from "./models/packager-config.js";
+import type { IDotnetDiscoveryService } from "./services/dotnet-discovery-service.js";
 /**
  * Base factory class containing common functionality for Node.js packager factories.
  */
 export declare abstract class BaseNodePackagerFactory {
+    /**
+     * Subclasses set this when they want {@link checkDotnetAvailability} to
+     * actually probe for `dotnet`. Left undefined, the check is a no-op.
+     */
+    protected dotnetDiscovery?: IDotnetDiscoveryService;
     /**
      * Returns the provided file system or creates a default NodeFileSystem.
      * @param config - Configuration options containing optional file system
@@ -18,7 +24,8 @@ export declare abstract class BaseNodePackagerFactory {
      */
     protected getOrCreateTelemetryService(config?: PackagerConfig): ITelemetryService;
     /**
-     * Checks dotnet CLI availability and logs appropriate messages.
+     * Checks dotnet CLI availability and logs appropriate messages. Skipped
+     * entirely when {@link dotnetDiscovery} is undefined.
      * @param logger - Logger instance to use for logging
      */
     protected checkDotnetAvailability(logger: IToolLogger): void;

package/dist/src/browser-project-packager-factory.d.ts

@@ -0,0 +1,26 @@
+import type { PackagerConfig } from "./models/packager-config.js";
+import { type IProjectPackager } from "./services/project-packager.js";
+/**
+ * Creates a ProjectPackager instance configured for browser usage.
+ *
+ * This is a convenience function that creates a BrowserProjectPackagerFactory and calls createAsync.
+ *
+ * @param options - Configuration options for the ProjectPackager
+ * @returns Promise<IProjectPackager> - A fully configured ProjectPackager instance ready for use in the browser.
+ *
+ * @example
+ * ```typescript
+ * // Import tools (triggers self-registration)
+ * import '@uipath/packager-tool-connector';
+ * import '@uipath/packager-tool-flow';
+ *
+ * // Create ProjectPackager
+ * const packager = await createBrowserProjectPackager({
+ *   logHandler: (message) => console.log(message)
+ * });
+ *
+ * // Tools are already registered and ready to use
+ * await packager.packAsync(options);
+ * ```
+ */
+export declare function createBrowserProjectPackager(options?: PackagerConfig): Promise<IProjectPackager>;

package/dist/src/browser.d.ts

@@ -0,0 +1,3 @@
+import "./i18n/index.js";
+export { BaseBrowserPackagerFactory } from "./base-browser-packager-factory.js";
+export { createBrowserProjectPackager } from "./browser-project-packager-factory.js";

package/dist/src/i18n/locales/en.d.ts

@@ -48,8 +48,37 @@ export declare const en: {
             readonly errors: {
                 readonly dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed.";
             };
+        };
+        readonly dotnet: {
             readonly info: {
-                readonly dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package.";
+                readonly available: "dotnet CLI is available (version {version}).";
+            };
+            readonly warnings: {
+                readonly notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available.";
+            };
+        };
+        readonly publish: {
+            readonly errors: {
+                readonly atLeastOnePackage: "At least one package path is required.";
+                readonly packageNotFound: "Package file not found: {path}";
+                readonly unknownDestination: "Unknown publish destination: {destination}";
+                readonly publishFailed: "Publish failed: {message}";
+                readonly failedToReadPackage: "Failed to read package file: {path}";
+                readonly localFolderRequired: "Local folder destination requires a folderPath.";
+                readonly localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}";
+                readonly nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.";
+                readonly nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}";
+                readonly nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}";
+                readonly orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.";
+                readonly orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.";
+                readonly orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}";
+                readonly orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}";
+                readonly orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}";
+                readonly orchestratorNoPackages: "No package files were provided to publish.";
+                readonly orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}";
+                readonly orchestratorUrlRequired: "Orchestrator URL is required.";
+                readonly getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}";
+                readonly getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}";
             };
         };
     };

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 import "./i18n/index.js";
-export type { IContextStorage, ITelemetryProvider, ITelemetryService, TelemetryContext, TelemetryProperties, } from "@uipath/telemetry";
-export { BrowserContextStorage, ConsoleTelemetryProvider, TelemetryService, } from "@uipath/telemetry";
+export type { IContextStorage, ITelemetryProvider, ITelemetryService, TelemetryContext, TelemetryProperties, } from "@uipath/common/telemetry";
+export { BrowserContextStorage, ConsoleTelemetryProvider, TelemetryService, } from "@uipath/common/telemetry";
 export type { PackagerConfig } from "./models/packager-config.js";
 export type { PackageSigningInfo, PackOptions, PublishInfo, ValidateOptions, } from "./models/packager-parameters.js";
 export { PackagerParameters, RulesConfigFileType, } from "./models/packager-parameters.js";
@@ -9,6 +9,10 @@ export type { UiPathProject } from "./models/project-models.js";
 export { ProjectPackOptions } from "./models/project-pack-options.js";
 export { ProjectRestoreOptions } from "./models/project-restore-options.js";
 export { ProjectValidateOptions } from "./models/project-validate-options.js";
+export type { LocalFolderDestination, NugetFeedDestination, OrchestratorCustomDestination, OrchestratorDestination, OrchestratorPersonalWorkspaceDestination, OrchestratorSharedLibrariesDestination, OrchestratorTenantProcessesDestination, PublishDestination, } from "./publish/models/publish-options.js";
+export { ProjectPublishOptions, PublishDestinationKind, } from "./publish/models/publish-options.js";
+export type { IProjectPublisher } from "./publish/services/project-publisher.js";
+export { ProjectPublisher } from "./publish/services/project-publisher.js";
 export type { IGovernancePolicyService } from "./services/governance-policy-service.js";
 export { GovernancePolicyService } from "./services/governance-policy-service.js";
 export type { IPackService } from "./services/pack-service.js";

package/dist/src/models/packager-config.d.ts

@@ -1,11 +1,11 @@
+import type { ITelemetryService } from "@uipath/common/telemetry";
 import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import type { ITelemetryService } from "@uipath/telemetry";
 import type { LogHandler } from "../services/tool-logger.js";
 /**
  * Configuration for packager factories.
  */
 export interface PackagerConfig {
-    /** Optional telemetry service. If not provided, a default TelemetryService with ConsoleTelemetryProvider is created. */
+    /** Optional telemetry service. If not provided, a default TelemetryService with DebugTelemetryProvider is created. */
     telemetryService?: ITelemetryService;
     /** Optional file system. If not provided, a default NodeFileSystem is created. */
     fileSystem?: IFileSystem;

package/dist/src/models/packager-parameters.d.ts

@@ -18,6 +18,10 @@ export interface ValidateOptions {
      * Whether to skip analysis
      */
     skipAnalyze: boolean;
+    /**
+     * Whether to skip validation
+     */
+    skipValidate: boolean;
     /**
      * Default severity level
      */
@@ -87,6 +91,10 @@ export declare abstract class PackagerParameters {
      * Input path to the solution or project folder
      */
     inputPath: string;
+    /**
+     * URL to download the project/solution snapshot for remote packing.
+     */
+    downloadUrl?: string;
     /**
      * Log level for the packager
      */

package/dist/src/models/project-build-options.d.ts

@@ -3,4 +3,8 @@ import { ProjectValidateOptions } from "./project-validate-options.js";
  * Project-specific parameters for build operations
  */
 export declare class ProjectBuildOptions extends ProjectValidateOptions {
+    /**
+     * Output package type passed through to the project build tool.
+     */
+    outputType?: string;
 }

package/dist/src/models/project-models.d.ts

@@ -13,14 +13,3 @@ export interface LoadedUiProject {
     /** Path to the project file (project.uiproj or webAppManifest.json) */
     projectFilePath: string;
 }
-/**
- * DTO matching the project.uiproj file format
- */
-export interface UiProject {
-    ProjectType: string;
-    /** Lowercase variant used by some project types (e.g., Flow) */
-    type?: string;
-    Name: string;
-    Description: string | null;
-    MainFile: string;
-}

package/dist/src/node.d.ts

@@ -1,9 +1,15 @@
 import "./i18n/index.js";
-export type { IContextStorage, ITelemetryProvider, ITelemetryService, TelemetryContext, TelemetryProperties, } from "@uipath/telemetry/node";
-export { ConsoleTelemetryProvider, NodeContextStorage, TelemetryService, } from "@uipath/telemetry/node";
+export type { IContextStorage, ITelemetryProvider, ITelemetryService, TelemetryContext, TelemetryProperties, } from "@uipath/common";
+export { DebugTelemetryProvider, NodeContextStorage, TelemetryService, } from "@uipath/common";
+/**
+ * @deprecated Use {@link DebugTelemetryProvider} instead. This re-export is kept
+ * for one release cycle to avoid breaking external consumers and will be removed
+ * in the next minor version.
+ */
+export { ConsoleTelemetryProvider } from "@uipath/common/telemetry";
 export { BaseNodePackagerFactory } from "./base-node-packager-factory.js";
 export type { PackagerConfig } from "./models/packager-config.js";
-export type { PackageSigningInfo, ValidateOptions, } from "./models/packager-parameters.js";
+export type { PackageSigningInfo, PackOptions, PublishInfo, ValidateOptions, } from "./models/packager-parameters.js";
 export { PackagerParameters, RulesConfigFileType, } from "./models/packager-parameters.js";
 export { ProjectBuildOptions } from "./models/project-build-options.js";
 export type { UiPathProject } from "./models/project-models.js";
@@ -11,6 +17,15 @@ export { ProjectPackOptions } from "./models/project-pack-options.js";
 export { ProjectRestoreOptions } from "./models/project-restore-options.js";
 export { ProjectValidateOptions } from "./models/project-validate-options.js";
 export { createNodeProjectPackager } from "./node-project-packager-factory.js";
+export type { LocalFolderDestination, NugetFeedDestination, OrchestratorCustomDestination, OrchestratorDestination, OrchestratorPersonalWorkspaceDestination, OrchestratorSharedLibrariesDestination, OrchestratorTenantProcessesDestination, PublishDestination, } from "./publish/models/publish-options.js";
+export { ProjectPublishOptions, PublishDestinationKind, } from "./publish/models/publish-options.js";
+export { createNodeProjectPublisher } from "./publish/node-project-publisher-factory.js";
+export type { IProjectPublisher } from "./publish/services/project-publisher.js";
+export { ProjectPublisher } from "./publish/services/project-publisher.js";
+export type { IDotnetDiscoveryService } from "./services/dotnet-discovery-service.js";
+export { DotnetDiscoveryService } from "./services/dotnet-discovery-service.js";
+export type { IGovernancePolicyService } from "./services/governance-policy-service.js";
+export { GovernancePolicyService } from "./services/governance-policy-service.js";
 export type { IPackService } from "./services/pack-service.js";
 export { PackService } from "./services/pack-service.js";
 export type { IPackageSignService } from "./services/package-sign-service.js";

package/dist/src/publish/models/publish-options.d.ts

@@ -0,0 +1,158 @@
+import type { ConnectionInfo } from "@uipath/solutionpackager-tool-core";
+/**
+ * Identifies a destination kind for publishing a .nupkg.
+ *
+ * The three orchestrator kinds map to feed purposes returned by
+ * `/orchestrator_/api/PackageFeeds/GetFeeds` (see `PackageFeedDto.purpose`).
+ * Callers pick the kind they want; the publisher resolves the matching
+ * feed itself.
+ */
+export declare enum PublishDestinationKind {
+    LocalFolder = "LocalFolder",
+    NugetFeed = "NugetFeed",
+    OrchestratorPersonalWorkspace = "OrchestratorPersonalWorkspace",
+    OrchestratorTenantProcesses = "OrchestratorTenantProcesses",
+    OrchestratorSharedLibraries = "OrchestratorSharedLibraries",
+    OrchestratorCustom = "OrchestratorCustom"
+}
+/**
+ * Local folder destination.
+ *
+ * Only meaningful in desktop (Node.js) usage. In the browser the operation
+ * targets the virtual BrowserFileSystem.
+ */
+export interface LocalFolderDestination {
+    kind: PublishDestinationKind.LocalFolder;
+    /**
+     * Absolute path to the folder where the .nupkg files will be written.
+     */
+    folderPath: string;
+    /**
+     * Overwrite existing files with the same name in the destination folder.
+     * Defaults to `true`.
+     */
+    overwrite?: boolean;
+}
+/**
+ * NuGet V2 feed destination (push API).
+ *
+ * The .nupkg is uploaded as multipart/form-data via PUT to
+ * `<feedUrl>` (when it already targets `.../api/v2/package`) or
+ * `<feedUrl>/api/v2/package` otherwise.
+ */
+export interface NugetFeedDestination {
+    kind: PublishDestinationKind.NugetFeed;
+    /**
+     * NuGet feed base URL (with or without trailing `/api/v2/package`).
+     */
+    feedUrl: string;
+    /**
+     * NuGet API key, sent as `X-NuGet-ApiKey`.
+     */
+    apiKey?: string;
+}
+/**
+ * Shared shape for all UiPath Orchestrator destinations.
+ *
+ * Package files are POSTed as `multipart/form-data` to
+ * `<orchestratorRoot>/odata/{Processes|Libraries}/UiPath.Server.Configuration.OData.UploadPackage`.
+ * The publisher resolves the target feed itself by calling
+ * `/api/PackageFeeds/GetFeeds` and matching on `PackageFeedDto.purpose`
+ * — callers don't pass any feed data.
+ *
+ * The Orchestrator URL is derived from `connectionInfo.cloudUrl`.
+ */
+interface OrchestratorBaseDestination {
+    /**
+     * Connection details for the target Orchestrator instance.
+     */
+    connectionInfo: ConnectionInfo;
+}
+/**
+ * Personal-workspace orchestrator feed (`Purpose: PersonalWorkspace`).
+ * The publisher resolves the workspace feed for the authenticated user
+ * and uploads to it; `X-UIPATH-OrganizationUnitId` is set from the
+ * resolved `feed.folderId`.
+ */
+export interface OrchestratorPersonalWorkspaceDestination extends OrchestratorBaseDestination {
+    kind: PublishDestinationKind.OrchestratorPersonalWorkspace;
+}
+/**
+ * Tenant-level "Processes" orchestrator feed (`Purpose: Processes`).
+ * Use this for processes that should be accessible across folders.
+ */
+export interface OrchestratorTenantProcessesDestination extends OrchestratorBaseDestination {
+    kind: PublishDestinationKind.OrchestratorTenantProcesses;
+}
+/**
+ * Tenant-level "Shared Libraries" orchestrator feed
+ * (`Purpose: Libraries`). Used for RPA libraries (project type
+ * ProcessLibrary / BusinessProcessLibrary).
+ *
+ * The orchestrator rejects tenant uploads to host shared library feeds unless
+ * a folder context is set. The caller must provide one as `folderId`;
+ * it is sent verbatim as `X-UIPATH-OrganizationUnitId`.
+ */
+export interface OrchestratorSharedLibrariesDestination extends OrchestratorBaseDestination {
+    kind: PublishDestinationKind.OrchestratorSharedLibraries;
+    /**
+     * Orchestrator folder Id used as the `X-UIPATH-OrganizationUnitId`
+     * header. Any selectable folder the user can see works — Studio
+     * Desktop sends whatever folder is currently in scope in its UI.
+     */
+    folderId: number;
+}
+/**
+ * Custom orchestrator destination where the caller supplies the full
+ * upload URL (e.g. `https://host/orchestrator_/odata/Processes/...
+ * UploadPackage?feedId=...`). The publisher POSTs the multipart form to
+ * `publishUrl` verbatim — no feed resolution, no URL derivation from
+ * `connectionInfo.cloudUrl`. `connectionInfo` is still used for the
+ * `Authorization` and `X-UIPATH-TenantId` headers.
+ */
+export interface OrchestratorCustomDestination extends OrchestratorBaseDestination {
+    kind: PublishDestinationKind.OrchestratorCustom;
+    /**
+     * Full publish URL — POSTed as-is.
+     */
+    publishUrl: string;
+    /**
+     * Optional folder context. When set, sent verbatim as
+     * `X-UIPATH-OrganizationUnitId`.
+     */
+    folderId?: number;
+    /**
+     * Optional NuGet feed API key. When set, sent as `X-NuGet-ApiKey`
+     * — required by ApiKey-authed shared library feeds that go through
+     * the NuGet v3 push protocol.
+     */
+    apiKey?: string;
+}
+/**
+ * Discriminated union of every supported Orchestrator destination.
+ */
+export type OrchestratorDestination = OrchestratorPersonalWorkspaceDestination | OrchestratorTenantProcessesDestination | OrchestratorSharedLibrariesDestination | OrchestratorCustomDestination;
+export type PublishDestination = LocalFolderDestination | NugetFeedDestination | OrchestratorDestination;
+/**
+ * Options accepted by `IProjectPublisher.publishAsync`.
+ */
+export declare class ProjectPublishOptions {
+    /**
+     * Absolute paths to the .nupkg files to publish.
+     */
+    packagePaths: string[];
+    /**
+     * Destination to publish to.
+     */
+    destination: PublishDestination;
+    constructor(
+    /**
+     * Absolute paths to the .nupkg files to publish.
+     */
+    packagePaths: string[], 
+    /**
+     * Destination to publish to.
+     */
+    destination: PublishDestination);
+}
+export {};

package/dist/src/publish/node-project-publisher-factory.d.ts

@@ -0,0 +1,6 @@
+import type { PackagerConfig } from "../models/packager-config.js";
+import { type IProjectPublisher } from "./services/project-publisher.js";
+/**
+ * Convenience function: creates a ProjectPublisher configured for Node.js usage.
+ */
+export declare function createNodeProjectPublisher(options?: PackagerConfig): Promise<IProjectPublisher>;

package/dist/src/publish/services/local-folder-publisher.d.ts

@@ -0,0 +1,19 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { LocalFolderDestination } from "../models/publish-options.js";
+/**
+ * Copies .nupkg files into a local folder.
+ *
+ * Uses the supplied `IFileSystem`, so it works on both the Node filesystem
+ * and the browser-side virtual filesystem - though in practice this
+ * destination only makes sense in desktop usage.
+ */
+export interface ILocalFolderPublisher {
+    publishAsync(packagePaths: string[], destination: LocalFolderDestination): Promise<ToolResult>;
+}
+export declare class LocalFolderPublisher implements ILocalFolderPublisher {
+    private readonly fileSystem;
+    private readonly logger;
+    constructor(fileSystem: IFileSystem);
+    publishAsync(packagePaths: string[], destination: LocalFolderDestination): Promise<ToolResult>;
+}

package/dist/src/publish/services/nuget-feed-publisher.d.ts

@@ -0,0 +1,29 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { NugetFeedDestination } from "../models/publish-options.js";
+/**
+ * Publishes .nupkg files to a NuGet feed using the standard `push` API.
+ *
+ * The feed receives a `PUT` with a multipart/form-data body containing the
+ * .nupkg under the field name `package`. Both v2 feeds (push at
+ * `<feedUrl>/api/v2/package`) and v3 feeds (push URL resolved from the
+ * service index's `PackagePublish/2.0.0` resource) are supported.
+ */
+export interface INugetFeedPublisher {
+    publishAsync(packagePaths: string[], destination: NugetFeedDestination): Promise<ToolResult>;
+}
+export declare class NugetFeedPublisher implements INugetFeedPublisher {
+    private readonly fileSystem;
+    private readonly logger;
+    constructor(fileSystem: IFileSystem);
+    publishAsync(packagePaths: string[], destination: NugetFeedDestination): Promise<ToolResult>;
+    private resolvePushUrl;
+    /**
+     * Resolve the push endpoint from a NuGet v3 service index (e.g.
+     * `http://localhost:5555/v3/index.json`). The index lists resources by
+     * `@type`; the push URL is the `@id` of the `PackagePublish/2.0.0`
+     * resource. See https://learn.microsoft.com/en-us/nuget/api/package-publish-resource.
+     */
+    private resolveFromServiceIndex;
+    private safeReadBody;
+}

package/dist/src/publish/services/orchestrator-feed-types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Local type and enum definitions for the small slice of the UiPath
+ * Orchestrator API that the publisher needs — package-feed discovery
+ * (`/api/PackageFeeds/GetFeeds`) and the folders-navigation lookup
+ * (`/api/FoldersNavigation/GetAllFoldersForCurrentUser`).
+ *
+ * These mirror the shapes that used to come from
+ * `@uipath/orchestrator-sdk`. That dependency was dropped so
+ * `@uipath/project-packager` can be published without pulling in the
+ * full generated Orchestrator client — the two GET calls the publisher
+ * performs are reimplemented over `fetch` (see
+ * {@link OrchestratorFeedsService}). The interfaces carry every field
+ * the SDK DTOs exposed; the enum string values are copied verbatim so
+ * comparisons against live API responses still hold. Enum fields the
+ * publisher never switches on (folder type / provision / permission
+ * model) are typed as plain `string` to avoid re-declaring enums that
+ * nobody reads.
+ */
+/**
+ * Connection details for talking to a single Orchestrator instance when
+ * the caller already has a token. `orchestratorUrl` should point at the
+ * Orchestrator root, with or without the trailing `/orchestrator_`
+ * segment — the feeds service tolerates both shapes.
+ */
+export interface OrchestratorConnection {
+    orchestratorUrl: string;
+    accessToken?: string;
+    tenantId?: string;
+}
+/** Feed purpose, as returned on `PackageFeedDto.purpose`. */
+export declare const PackageFeedDtoPurposeEnum: {
+    readonly Undefined: "Undefined";
+    readonly Processes: "Processes";
+    readonly Libraries: "Libraries";
+    readonly PersonalWorkspace: "PersonalWorkspace";
+    readonly FolderHierarchy: "FolderHierarchy";
+};
+export type PackageFeedDtoPurposeEnum = (typeof PackageFeedDtoPurposeEnum)[keyof typeof PackageFeedDtoPurposeEnum];
+/** Feed authentication type, as returned on `PackageFeedDto.authenticationType`. */
+export declare const PackageFeedDtoAuthenticationTypeEnum: {
+    readonly Secure: "Secure";
+    readonly ApiKey: "ApiKey";
+    readonly Basic: "Basic";
+};
+export type PackageFeedDtoAuthenticationTypeEnum = (typeof PackageFeedDtoAuthenticationTypeEnum)[keyof typeof PackageFeedDtoAuthenticationTypeEnum];
+/**
+ * A package feed the user can publish to. `/api/PackageFeeds/GetFeeds`
+ * returns these with camelCase property names, so the response is used
+ * as-is.
+ */
+export interface PackageFeedDto {
+    name?: string;
+    purpose?: PackageFeedDtoPurposeEnum;
+    isShared?: boolean;
+    isPublic?: boolean;
+    isExternal?: boolean;
+    feedUrl?: string;
+    publishUrl?: string;
+    authenticationType?: PackageFeedDtoAuthenticationTypeEnum;
+    apiKey?: string;
+    basicUserName?: string;
+    basicPassword?: string;
+    folderId?: number;
+    supportedProjectTypes?: string[];
+    id?: string;
+}
+/** Folder feed type, as returned on `ExtendedFolderDto.feedType`. */
+export declare const ExtendedFolderDtoFeedTypeEnum: {
+    readonly Undefined: "Undefined";
+    readonly Processes: "Processes";
+    readonly Libraries: "Libraries";
+    readonly PersonalWorkspace: "PersonalWorkspace";
+    readonly FolderHierarchy: "FolderHierarchy";
+};
+export type ExtendedFolderDtoFeedTypeEnum = (typeof ExtendedFolderDtoFeedTypeEnum)[keyof typeof ExtendedFolderDtoFeedTypeEnum];
+/**
+ * A folder visible to the current user. Unlike the feeds endpoint,
+ * `/api/FoldersNavigation/GetAllFoldersForCurrentUser` returns
+ * PascalCase property names (`DisplayName`, `FeedType`, `Id`, …), so the
+ * raw response is mapped to this camelCase shape before use.
+ */
+export interface ExtendedFolderDto {
+    isSelectable?: boolean;
+    hasChildren?: boolean;
+    level?: number;
+    key?: string;
+    displayName?: string;
+    fullyQualifiedName?: string;
+    description?: string;
+    folderType?: string;
+    isPersonal?: boolean;
+    provisionType?: string;
+    permissionModel?: string;
+    parentId?: number;
+    parentKey?: string;
+    feedType?: ExtendedFolderDtoFeedTypeEnum;
+    id?: number;
+}

package/dist/src/publish/services/orchestrator-feeds-service.d.ts

@@ -0,0 +1,44 @@
+import type { ExtendedFolderDto, OrchestratorConnection, PackageFeedDto } from "./orchestrator-feed-types.js";
+export type { OrchestratorConnection } from "./orchestrator-feed-types.js";
+/**
+ * Public API of {@link OrchestratorFeedsService}.
+ *
+ * Mirrors the surface of Studio desktop's
+ * `IOrchestratorFeedsService` — the test browser, the Node CLI, and the
+ * robot all need a way to enumerate the feeds a user can publish to
+ * before they pick one.
+ */
+export interface IOrchestratorFeedsService {
+    /**
+     * Lists every feed the authenticated user can publish to. Returns
+     * an empty array when the API responds 200 with no feeds.
+     */
+    getAccessibleFeedsAsync(connection: OrchestratorConnection): Promise<PackageFeedDto[]>;
+    /**
+     * Lists folders the authenticated user can see, including the
+     * special personal-workspace folder. Use the `feedType` field to
+     * find folder-purpose matches (e.g. `PersonalWorkspace`) — feeds
+     * returned from `getAccessibleFeedsAsync` only carry `Processes`
+     * or `Libraries` as their `purpose`, so this is the only way to
+     * tell which folder feed is the user's PW.
+     */
+    getFoldersForCurrentUserAsync(connection: OrchestratorConnection): Promise<ExtendedFolderDto[]>;
+}
+/**
+ * Talks directly to the package-feeds and folders-navigation endpoints
+ * over `fetch`. Studio Web's publisher uses the returned `publishUrl`
+ * (and `id` as the `feedId` query string) to upload the .nupkg — this
+ * service is the discovery half of that flow.
+ *
+ * These were previously two typed calls through
+ * `@uipath/orchestrator-sdk`; both are plain authenticated GETs, so
+ * they're issued directly here to keep the published package free of the
+ * full generated Orchestrator client.
+ */
+export declare class OrchestratorFeedsService implements IOrchestratorFeedsService {
+    private readonly logger;
+    constructor();
+    getAccessibleFeedsAsync(connection: OrchestratorConnection): Promise<PackageFeedDto[]>;
+    getFoldersForCurrentUserAsync(connection: OrchestratorConnection): Promise<ExtendedFolderDto[]>;
+    private ensureOrchestratorUrl;
+}