@uipath/solution-sdk 1.202.0 → 1.203.0-preview.160

package/dist/src/index.d.ts

@@ -13,4 +13,4 @@ export type { BundleResult, SolutionImportResponse, StudioWebConfig, StudioWebSo
 export type { SolutionUploadOperation } from "./upload-service";
 export { buildSolutionUploadFailureOutput, importSolution, isSolutionUploadHttpError, overwriteSolution, SolutionUploadHttpError, solutionExistsOnStudioWeb, uploadOrOverwriteSolution, } from "./upload-service";
 export { SDK_USER_AGENT } from "./user-agent.js";
-export { collectFiles, createZipFromDir } from "./zip-utils";
+export { collectFiles, createZipFromDir, finalizeZip64 } from "./zip-utils";

package/dist/src/resources/commands/project-utils.d.ts

@@ -89,5 +89,10 @@ export declare function restoreSolutionFile(filePath: string, rawContent: string
  * `subType` is forwarded to the SDK's project template picker. For AppV2
  * projects: pass `"Coded"` for a regular coded app or `"CodedAction"` for a
  * coded action app; leave undefined for other project types.
+ *
+ * Spec-level patches to the emitted artefact resources (App→Package wire,
+ * `isOverridable: true` round-trip default) live in the registered
+ * `ArtefactPairBindingProvider` and fire at write time — this function
+ * stays as thin as before that concern existed.
  */
 export declare function createProjectInSolutionBuilder(solutionDir: string, projectId: string, projectName: string, projectType: string, subType?: string): Promise<Error | null>;

package/dist/src/resources/index.d.ts

@@ -17,6 +17,9 @@ export * from "./providers/resource-builder-init";
 export * from "./services/entry-point-spec-enhancer";
 export * from "./services/local-resource-matcher";
 export * from "./services/project-artifacts-service";
+export * from "./services/project-template-types";
+export { normalizeResourceCasing, normalizeResourceFileCasing, saveCasingNormalized, } from "./services/resource-casing";
 export * from "./services/resource-refresh-service";
+export * from "./services/resource-remote-sync";
 export * from "./services/solution-manifest";
 export * from "./services/sync-resources-from-bindings";

package/dist/src/resources/providers/artefact-pair-binding-provider.d.ts

@@ -0,0 +1,21 @@
+import type { ISolutionContext } from "@uipath/resource-builder-sdk/models";
+import { MultiFileSolutionDefinitionFactory, MultiFileSolutionDefinitionProvider, type SolutionDefinition } from "@uipath/resource-builder-sdk/solution";
+/**
+ * Runs on every `writeAsync` to backfill artefact-pair wiring the TS SDK's
+ * `bindArtefactResources` doesn't yet port from the C# `BindAppResources`
+ * else-branch + `EnsureSolutionResourceFields`. Two idempotent patches:
+ * app→package linkage (spec.package.key + dependency) and isOverridable=true
+ * on the paired app+package. Timing matters — before the serializer strips
+ * `undefined`-valued metadata-declared spec keys.
+ */
+export declare class ArtefactPairBindingProvider extends MultiFileSolutionDefinitionProvider {
+    writeAsync(context: ISolutionContext, solution: SolutionDefinition, cancellationToken?: AbortSignal): Promise<void>;
+}
+/**
+ * The SDK's DI resolves `ISolutionDefinitionFactory` at request time
+ * (`saveChangesAsync` → `saveAsync`), so registering the provider alone
+ * isn't enough — the factory has to produce it too.
+ */
+export declare class ArtefactPairBindingSolutionDefinitionFactory extends MultiFileSolutionDefinitionFactory {
+    getProviderAsync(): Promise<ArtefactPairBindingProvider>;
+}

package/dist/src/resources/providers/file-storage-provider.d.ts

@@ -1,4 +1,5 @@
-import type { IFileStorageProvider, IFileStorageProviderFactory, ISolutionContext } from "@uipath/resource-builder-sdk";
+import type { ISolutionContext } from "@uipath/resource-builder-sdk/models";
+import type { IFileStorageProvider, IFileStorageProviderFactory } from "@uipath/resource-builder-sdk/providers";
 /**
  * Factory for creating FileSystemFileStorageProvider instances.
  */

package/dist/src/resources/providers/resource-builder-init.d.ts

@@ -1,16 +1,16 @@
-import { type IResourceBuilderServices } from "@uipath/resource-builder-sdk";
+import type { IResourceBuilderServices } from "@uipath/resource-builder-sdk";
 /**
- * Creates a configured ResourceBuilderServices instance for CLI usage.
- * Uses SolutionAccessProvider which maps SDK service scopes to full
- * tenant-scoped gateway URLs, enabling server-side SDK operations
- * (updateConfigurationAsync, addOrUpdateResourceToSolutionAsync, etc.).
+ * CLI entry for ResourceBuilderServices. Adds three providers on top of the SDK
+ * defaults: `ArtefactPairBindingSolutionDefinitionFactory` (fills the
+ * app+package linkage gap in `bindArtefactResources`), `EntryPointSpecEnhancer`
+ * (overlays the on-disk entry points at GET), and
+ * `CliResourceBuilderLoggerFactory`, which replaces the SDK's default logger —
+ * that one prints its message templates unfilled (`{solutionKey}`, `%s`) and
+ * bypasses `--log-level` / `--log-file`; see that file for why both matter.
  *
- * `EntryPointSpecEnhancer` is registered so artefact resources (resources
- * with a `projectKey`) reflect the latest `entry-points.json` from disk at
- * read time, instead of the snapshot captured at `solution projects add`.
- *
- * `CliResourceBuilderLoggerFactory` replaces the SDK's default logger, which
- * prints its message templates unfilled (`{solutionKey}`, `%s`) and bypasses
- * `--log-level` / `--log-file` — see that file for why both matter.
+ * There is no caller-supplied enhancer hook: a project type's knowledge
+ * reaches the resources through the contribution contract at pack / refresh
+ * time (`solution-tool/src/services/project-contributions.ts`), not through a
+ * read-time enhancer that would make every read load a tool bundle.
  */
 export declare function createResourceBuilderServices(): Promise<IResourceBuilderServices>;

package/dist/src/resources/providers/solution-access-provider.d.ts

@@ -1,4 +1,5 @@
-import type { AuthenticationInfo, IAccessProvider } from "@uipath/resource-builder-sdk";
+import type { AuthenticationInfo } from "@uipath/resource-builder-sdk/models";
+import type { IAccessProvider } from "@uipath/resource-builder-sdk/providers";
 /**
  * IAccessProvider that maps SDK service scopes to full tenant-scoped URLs.
  * Unlike CliAccessProvider (which returns bare baseUrl), this builds the correct

package/dist/src/resources/services/entry-point-spec-enhancer.d.ts

@@ -1,5 +1,7 @@
 import { type IFileSystem } from "@uipath/filesystem";
-import type { IArtifactResourceSpecEnhancer, ISolutionContext, ResourceDefinition, ResourcePropertyMetadata } from "@uipath/resource-builder-sdk";
+import type { ISolutionContext } from "@uipath/resource-builder-sdk/models";
+import type { IArtifactResourceSpecEnhancer, ResourcePropertyMetadata } from "@uipath/resource-builder-sdk/services";
+import type { ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
 /**
  * Reads the project's `entry-points.json` at GET time and projects the primary
  * entry points onto the resource spec, so consumers see the current on-disk
@@ -20,8 +22,25 @@ export declare class EntryPointSpecEnhancer implements IArtifactResourceSpecEnha
     constructor(fs?: IFileSystem);
     enhanceSpecAsync(context: ISolutionContext, resource: ResourceDefinition, _propertiesMetadata: Map<string, ResourcePropertyMetadata>, spec: Map<string, unknown>, _cancellationToken?: AbortSignal): Promise<void>;
     private applyEntryPointAsync;
-    private findSolutionFileAsync;
 }
+/**
+ * The entry-point spec keys for one project, read fresh off disk.
+ *
+ * One implementation, two consumers: `EntryPointSpecEnhancer` overlays them at
+ * GET time, and solution-tool's contribution driver writes the same keys onto
+ * the resource JSON so they survive into the packed solution. Keeping the
+ * parsing here is what stops the two paths disagreeing on the shape.
+ *
+ * `entryPoints` carries the raw `entry-points.json` text (with `$schema`,
+ * `$id`, indentation) — matches what Studio Web returns on the process
+ * resource spec. `entryPointName` / `entryPointUniqueId` name the single
+ * primary entry, and are `null` whenever the project has zero or several.
+ *
+ * Returns `undefined` when there is nothing to say (project not in the
+ * manifest, no `entry-points.json`, empty file). Throws on malformed JSON —
+ * both callers catch and warn.
+ */
+export declare function computeEntryPointSpec(fs: IFileSystem, solutionDir: string, projectKey: string): Promise<Record<string, unknown> | undefined>;
 /**
  * Applies `EntryPointSpecEnhancer` against a plain-object spec returned by the
  * SDK's `getConfigurationAsync` path. Used by `resource get` until the SDK

package/dist/src/resources/services/local-resource-matcher.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceDefinition } from "@uipath/resource-builder-sdk";
+import type { ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
 /**
  * Pure, dependency-free matching primitives for local solution resources.
  * A leaf module on purpose: `sync-resources-from-bindings` and

package/dist/src/resources/services/project-template-types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Whether the resource-builder resolves this project type's artefact resources
+ * from its bare `type` row, rather than only from a `<type>_<subType>` one.
+ *
+ * Callers use it to decide who generates a project's resources. A type with a
+ * bare row can be registered from the host at `projects add` time. A type
+ * without one cannot: the variant that picks its row lives in a file format the
+ * project's own tool owns, so its resources arrive later — at `<tool> init`
+ * inside a solution, or at pack / upload / `resources refresh`, where the tool
+ * is loaded and reports its `projectSubType` through the project resource
+ * contribution and `reconcileProjectsAsync` generates them.
+ *
+ * Reading the answer off the table keeps the list of such types out of every
+ * caller (AGENTS.md Hard Rule #19): the table is the resource-builder's own,
+ * and a type added to it needs no edit here or in the CLI.
+ *
+ * Registering with no subType is not a harmless no-op, which is why the
+ * distinction matters. Measured against resource-builder-sdk
+ * 2025.11.0-alpha5891-4020, on a fresh solution:
+ *
+ * - `createProjectAsync` with a type that has no bare row and no subType
+ *   writes `process/process/<name>.json` — the SDK's Process fallback, i.e.
+ *   the wrong resource, which then has to be repaired.
+ * - `reconcileProjectsAsync` with the right subType repairs it in full,
+ *   including deleting that stale `process/` artefact, and corrects an app
+ *   resource generated under the wrong variant.
+ * - `reconcileProjectsAsync` with no subType is inert, never destructive.
+ */
+export declare function hasBareTemplateRow(projectType: string): boolean;
+/**
+ * Whether the table has any row for this type — bare or `<type>_<subType>`.
+ * A type with none declares no template-generated resources at all, so
+ * nothing is left for a later tool run to generate.
+ */
+export declare function hasAnyTemplateRow(projectType: string): boolean;

package/dist/src/resources/services/resource-casing.d.ts

@@ -0,0 +1,24 @@
+import type { ISolutionBuilder, SolutionDefinition } from "@uipath/resource-builder-sdk";
+export declare function lowerFirstChar(value: string): string;
+export declare function normalizeResourceCasing(solution: Pick<SolutionDefinition, "resources"> | null | undefined): number;
+/**
+ * Normalize in-memory casing then dispose. Callers run
+ * `normalizeResourceFileCasing(dir)` separately when this returns null
+ * because the file-level repair needs the resolved solution dir and
+ * should only run when dispose succeeded.
+ */
+export declare function saveCasingNormalized(builder: Pick<ISolutionBuilder, "disposeAsync"> & {
+    context: {
+        loadAsync(): Promise<Pick<SolutionDefinition, "resources">>;
+    };
+}): Promise<Error | null>;
+/**
+ * The SDK reads `kind`/`type` through `toLowerFirstChar` but writes them back
+ * verbatim, and its stale-path check compares paths case-insensitively. A
+ * server-cased file therefore gains a lower-cased twin on the next save, both
+ * carrying the same resource key, and the load after that throws "Node already
+ * added to the graph" on a case-sensitive filesystem. Move every resource file
+ * to the path the next save targets, and drop the twins a corrupted tree
+ * already carries.
+ */
+export declare function normalizeResourceFileCasing(solutionDir: string): Promise<string[]>;

package/dist/src/resources/services/resource-refresh-service.d.ts

@@ -5,6 +5,13 @@ export interface ResourceRefreshOptions {
     loginValidity?: number;
     /** Pin auth to this exact `.uipath/.auth` path. */
     envFilePath?: string;
+    /**
+     * Resolves each project's contributed subType, keyed by the `.uipx`
+     * project `Id`. Called after the folder and auth checks pass and before
+     * the sync, so a caller that has to load tool bundles to answer only pays
+     * for them on a run that is otherwise going to proceed.
+     */
+    resolveProjectSubTypesAsync?: () => Promise<ReadonlyMap<string, string>>;
 }
 export interface ResourceRefreshSuccess {
     ok: true;

package/dist/src/resources/services/resource-remote-sync.d.ts

@@ -0,0 +1,67 @@
+/** Discriminator for {@link ResourceRemoteSyncFailure}; library callers can ignore the tag and read `.message` / `.ok`. */
+export type ResourceRemoteSyncFailureReason = "solution_not_found" | "not_a_solution" | "auth_failed" | "resource_not_found" | "no_remote_reference" | "comparison_unavailable" | "sync_failed" | "save_failed";
+export interface ResourceRemoteSyncOptions {
+    /** Write the cloud definition over the local one. When `false` (default) nothing is written and the result only reports the drift. */
+    force?: boolean;
+    /** Minimum minutes before token expiration to trigger a refresh. Default `10` (matches the CLI's `--login-validity`). */
+    loginValidity?: number;
+    /** Pin auth to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+}
+export interface ResourceRemoteSyncSuccess {
+    ok: true;
+    /** `true` when the cloud definition was written to disk; `false` for a drift-only (no `--force`) run. */
+    applied: boolean;
+    key: string;
+    /** Spec property names that differ between the local and the cloud definition, sorted. Empty when the two already agree. */
+    changed: string[];
+    /** Properties that still differ from the cloud after a write, because the SDK declined to set them (reference, read-only or unknown to the kind metadata). Empty on a clean sync. */
+    skipped: string[];
+    /** The resulting local spec — post-write when `applied`, unchanged otherwise. */
+    spec: Record<string, unknown>;
+}
+export interface ResourceRemoteSyncFailure {
+    ok: false;
+    reason: ResourceRemoteSyncFailureReason;
+    /** Human-readable summary suitable for top-level surfacing. */
+    message: string;
+}
+export type ResourceRemoteSyncResult = ResourceRemoteSyncSuccess | ResourceRemoteSyncFailure;
+/**
+ * Programmatic core of `uip solution resources edit --source remote`: replaces a
+ * solution resource's spec with the current cloud definition it was imported from.
+ *
+ * This is the one path that overwrites an already-imported resource. `refresh` is
+ * deliberately import-only (see `sync-resources-from-bindings`), so a field added
+ * to a cloud entity after the initial import never reaches the solution without
+ * this command.
+ *
+ * Mechanism: read the cloud side with `getResourceConfigurationsComparisonAsync`
+ * (which returns the solution config and the FPS export side by side and writes
+ * nothing), then hand that spec to `updateConfigurationAsync` — the same writer
+ * `resources edit --patch` uses. It mutates the existing resource in place, so
+ * the file keeps its path and the resource keeps its key and name.
+ *
+ * **Two richer-looking SDK calls were tried first and both are wrong here.**
+ *
+ * `syncConfigurationFromReferenceAsync` looks the resource's cloud source up via
+ * `getDebugOverwrites`, which calls the *server* rather than reading the local
+ * `debug_overwrites.json`. For a solution never uploaded to Studio Web the server
+ * has nothing, so it returns the resource untouched and reports success — every
+ * `--force` was a silent no-op. Confirmed live: `getDebugOverwrites size: 0`
+ * while the file on disk held the row.
+ *
+ * `addOrUpdateResourceToSolutionAsync` (and the command behind it) re-imports the
+ * FPS export, which carries the *server* casing of `kind` — `Queue`, not `queue`.
+ * The re-add therefore writes a second file at `resources/.../Queue/<name>.json`
+ * beside the original `queue/<name>.json`. On a case-sensitive filesystem those
+ * are two files for one resource key: the load throws "Node already added to the
+ * graph", and once `normalizeResourceFileCasing` folds them it keeps the one
+ * already at the target path — the stale one — silently discarding the write.
+ * Reproduced on a case-sensitive volume; it is why only the Linux e2e leg failed.
+ *
+ * What survives from that: never trust a write to have happened. The spec is read
+ * back and diffed, and anything the writer declined to set is reported in
+ * `skipped` rather than folded into a success.
+ */
+export declare function resourceRemoteSyncAsync(solutionPath: string | undefined, resourceKey: string, options?: ResourceRemoteSyncOptions): Promise<ResourceRemoteSyncResult>;

package/dist/src/resources/services/solution-manifest.d.ts

@@ -1,9 +1,23 @@
+import { type IFileSystem } from "@uipath/filesystem";
+export interface SolutionManifestProject {
+    Id?: unknown;
+    Type?: unknown;
+    ProjectRelativePath?: unknown;
+}
+export interface SolutionManifest {
+    Projects?: SolutionManifestProject[];
+}
 /**
- * Throw if `dir` doesn't directly contain a `.uipx` manifest. Stricter than
- * `findSolutionFile` (which walks up to find one) — write commands should not
- * silently mutate the wrong folder when run from an arbitrary cwd.
- *
- * Lives in `services/` (not `commands/project.ts`) so callers can mock the
- * check without pulling in the full project-commands module.
+ * Stricter than `findSolutionFile` (which walks up to find one) — write
+ * commands must not silently mutate the wrong folder when run from an
+ * arbitrary cwd.
  */
 export declare function assertSolutionManifest(dir: string): Promise<void>;
+/**
+ * Soft-fails to `undefined` on missing / unreadable / invalid `.uipx`.
+ * Consumers (read-time enhancers, design-time reconcilers) need
+ * tolerance — pack's own fail-fast policy lives elsewhere
+ * (`assertSolutionManifest`, and each project tool's own contribution errors).
+ */
+export declare function readSolutionManifest(fs: IFileSystem, solutionDir: string): Promise<SolutionManifest | undefined>;
+export declare function resolveProjectDirFromManifest(fs: IFileSystem, solutionDir: string, projectKey: string): Promise<string | undefined>;

package/dist/src/resources/services/sync-resources-from-bindings.d.ts

@@ -1,4 +1,5 @@
-import { type IResourceBuilderServices, type ISolutionBuilder, type ResourceDefinition } from "@uipath/resource-builder-sdk";
+import type { IResourceBuilderServices } from "@uipath/resource-builder-sdk";
+import type { ISolutionBuilder, ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
 interface RequiredPropertyDefault {
     property: string;
     /** Empty placeholder value matching the property's declared type. */
@@ -42,7 +43,7 @@ interface SyncResult {
  * @param solutionDir - Path to the solution directory
  * @param projectPaths - Specific project paths to scan (if omitted, scans all projects in .uipx)
  */
-export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[]): Promise<SyncResult>;
+export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[], projectSubTypes?: ReadonlyMap<string, string>): Promise<SyncResult>;
 /**
  * Mirror of SDK's private `addResourceWithUniqueName`
  * (resource-builder-sdk index.js:673): if any other resource of the same
@@ -148,4 +149,4 @@ export declare function readUipxProjects(solutionDir: string): Promise<UipxProje
  * Sync resources from bindings with logging. Non-fatal — logs warnings
  * on failure and continues. Used by pack and upload before packaging.
  */
-export declare function syncAndLog(solutionDir: string): Promise<void>;
+export declare function syncAndLog(solutionDir: string, projectSubTypes?: ReadonlyMap<string, string>): Promise<void>;

package/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@uipath/solution-sdk",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.202.0",
+    "version": "1.203.0-preview.160",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -39,5 +40,5 @@
         "dist"
     ],
     "private": false,
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }