@uipath/common 1.200.0-preview.120 → 1.201.0-preview.121

package/dist/option-validators.d.ts

@@ -33,3 +33,17 @@ export declare function parseBoundedInt(raw: string, optionName: string, bounds:
 }): number;
 export declare function parsePositiveInteger(raw: string): number | undefined;
 export declare function parseNonNegativeInteger(raw: string): number | undefined;
+/**
+ * Split an OAuth scope list into individual scope names.
+ *
+ * Accepts both separators the CLI has historically used: the OAuth2
+ * space-separated form (`uip login --scope`) and the comma-separated form
+ * (`uip admin external-apps --user-scope`). Space is safe to split on
+ * because RFC 6749 uses it as the scope delimiter. Comma is not reserved by
+ * the RFC — a `scope-token` may legally contain one — but no UiPath scope
+ * name does, and the server validates every name it is sent, so a
+ * wrongly-split name fails as unknown rather than granting anything extra.
+ *
+ * Returns an empty array for undefined, empty, or separator-only input.
+ */
+export declare function splitScopeList(raw: string | undefined): string[];

package/dist/output-codecs.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Lazy loaders for the two output codecs that only some invocations need.
+ *
+ * `formatter.ts` is imported by every command in every tool, so anything it
+ * imports statically is parsed on every `uip` invocation — including
+ * `uip <tool> -h`. `js-yaml` (101 KB) is only reached by `--output yaml` and
+ * `@jmespath-community/jmespath` (68 KB) only by `--output-filter`, so both
+ * live behind `await import` here instead.
+ *
+ * The API is split in two on purpose:
+ *
+ *  - `loadOutputCodecsAsync` is awaited from the async paths that already know
+ *    what the user asked for — the CLI host right after it resolves `--output`
+ *    and `--output-filter`, and `trackedAction` before it runs a handler.
+ *  - `getYamlCodec` / `getJmespathCodec` are the synchronous accessors
+ *    `OutputFormatter` uses, because the formatter API is synchronous.
+ *
+ * Loaded modules live in cross-bundle singleton slots: each tool bundles its
+ * own copy of `@uipath/common`, so a module-level variable would be loaded by
+ * the host and then missing in the tool. See `singleton.ts`.
+ */
+/** The slice of `js-yaml` the formatter uses. */
+export interface YamlCodec {
+    dump: (data: unknown) => string;
+}
+/** The slice of `@jmespath-community/jmespath` the formatter uses. */
+export interface JmespathCodec {
+    compile: (expression: string) => unknown;
+    search: (data: never, expression: string) => unknown;
+}
+/** Which codecs an invocation needs, derived from the resolved CLI options. */
+export interface OutputCodecsNeeded {
+    /** True when the resolved output format is `yaml`. */
+    yaml?: boolean;
+    /** True when an `--output-filter` expression is present. */
+    filter?: boolean;
+}
+/**
+ * Load the codecs this invocation needs, if they are not loaded already.
+ *
+ * Safe to call repeatedly — a codec already in its slot is not re-imported.
+ * Call before any `OutputFormatter` output that could use them.
+ */
+export declare function loadOutputCodecsAsync(needed: OutputCodecsNeeded): Promise<void>;
+/**
+ * The loaded YAML codec, or `undefined` when nothing preloaded it.
+ *
+ * `undefined` means a code path produced `--output yaml` output without
+ * passing through the CLI host or `trackedAction` — a bug in that path, not a
+ * user error, so callers should throw rather than silently emit JSON.
+ */
+export declare function getYamlCodec(): YamlCodec | undefined;
+/** The loaded JMESPath codec, or `undefined` when nothing preloaded it. */
+export declare function getJmespathCodec(): JmespathCodec | undefined;
+/** Test seam — drops both codecs so a spec can assert the unloaded path. */
+export declare function resetOutputCodecs(): void;

package/dist/solution-project-types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Guidance for a project type a solution cannot contain, or `null` when allowed.
+ * Lives in `@uipath/common` so `solution-tool`'s packager resolver can ask
+ * without importing the `@uipath/solution-sdk` barrel (which drags
+ * `@uipath/studioweb-sdk` in).
+ *
+ * A library registered as a project does not fail late, it deploys *wrong*: the
+ * resource builder has no library template, falls through to the default, and
+ * mints `kind: process`. Deploy then creates an Orchestrator process backed by a
+ * library package, which has no entry point. The SDK metadata agrees a library
+ * is not project-shaped: `kind: library` is `scope: Tenant`,
+ * `supportsInLineCreation: false`.
+ *
+ * Case-insensitive — `.uipx` writes PascalCase `Type`, `project.json` uses
+ * `designOptions.outputType`.
+ *
+ * Takes `unknown` because one caller (`ensurePackagerTools`) reads `Type`
+ * straight out of `.uipx` JSON, where it can be absent or not a string. Only a
+ * type positively known to be unsupported is rejected, so anything else is
+ * allowed through to the resolvers, which warn on their own.
+ */
+export declare function unsupportedSolutionProjectType(projectType: unknown): string | null;

package/dist/telemetry/proxy-http-agent.d.ts

@@ -0,0 +1,2 @@
+export declare function setProxyAuthHttpsAgent(agent: unknown): void;
+export declare function getProxyAuthHttpsAgent(): unknown;

package/dist/tool-provider.d.ts

@@ -1,28 +1,8 @@
 /**
- * Cross-module bridge for packager factory and tool-module resolution.
+ * Cross-module bridge for packager factory resolution.
  */
 export type PackagerFactoryProvider = (verb: string) => Promise<void>;
 export declare function setPackagerFactoryProvider(provider: PackagerFactoryProvider): void;
-export type ToolModuleProvider = (verb: string, moduleName: string) => Promise<unknown>;
-export declare function setToolModuleProvider(provider: ToolModuleProvider): void;
-/**
- * Resolve another tool's library entry point (its `dist/<module>.js` subpath
- * export) at runtime and return the module namespace.
- *
- * Prefers the registered provider (installed by the CLI — it can install the
- * tool on demand and imports the entry by absolute path). With no provider —
- * a library caller — falls back to importing `<packageName>/<moduleName>`,
- * which resolves when the tool package is installed next to the caller.
- *
- * This is how one tool uses another tool's code without bundling it: the
- * multi-megabyte implementation ships once, in the tool that owns it.
- *
- * @param verb - CLI tool verb that owns the module (e.g. `"solution"`).
- * @param packageName - npm package behind that verb, used for the fallback
- * import (e.g. `"@uipath/solution-tool"`).
- * @param moduleName - subpath entry to load (e.g. `"init"`, `"resource"`).
- */
-export declare function ensureToolModule(verb: string, packageName: string, moduleName: string): Promise<unknown>;
 /**
  * Resolve the packager factory for a tool verb.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/common",
   "license": "MIT",
-  "version": "1.200.0-preview.120",
+  "version": "1.201.0-preview.121",
   "description": "Common infrastructure needed by uip tools.",
   "repository": {
     "type": "git",
@@ -71,5 +71,5 @@
     "mihaigirleanu",
     "vlad-uipath"
   ],
-  "gitHead": "173ad4b4930bd3e17a493b32e9f1c3c616ea1c10"
+  "gitHead": "c70ccfc0b12e637441d67df1d212b71d7784b5f8"
 }

package/dist/solution-project-artifacts.d.ts

@@ -1,43 +0,0 @@
-/**
- * Shared `ensureProjectArtifacts` used by every `*-tool init` path (agent,
- * case, codedapp, flow, maestro). Lives here so the five tools don't each
- * carry a copy; each tool re-exports it from its own
- * `src/services/project-artifacts.ts` shim (the browser-build
- * `excludedImports` stub mechanism resolves only relative paths under each
- * tool's own src tree).
- */
-/** Options forwarded to solution-tool's `addProjectArtifactsToSolutionAsync`. */
-export interface EnsureProjectArtifactsArgs {
-    /** Absolute path to the solution directory (containing the `.uipx`). */
-    solutionDir: string;
-    /** Stable project key — must match the `Id` in `.uipx` `Projects[]`. */
-    projectId: string;
-    /** Display name for the project; typically the project folder name. */
-    projectName: string;
-    /** Project type as written to `project.uiproj` (e.g. `Flow`, `Agent`). */
-    projectType: string;
-    /** Optional SDK subType (AppV2: `"Coded"` / `"CodedAction"`). */
-    projectSubType?: string;
-}
-/**
- * Result envelope. Structurally identical to `ProjectArtifactsResult` in
- * `@uipath/solution-sdk/resources` — declared here too because this
- * package sits below `solution-sdk` in the dependency graph and cannot import
- * from it.
- */
-export interface ProjectArtifactsResult {
-    /** True when artifact resources were generated. */
-    Created: boolean;
-    /** Error message when `Created` is `false`. */
-    Error?: string;
-}
-/**
- * Generate the `resources/solution_folder/...` artifact-resource entries for
- * a project that has just been registered in its parent solution's `.uipx`.
- *
- * The implementation is resolved at runtime from the installed
- * `@uipath/solution-tool` (through the CLI host's tool-module provider, which
- * installs it on demand), so the multi-megabyte resource-builder chain is
- * never bundled into the calling tool.
- */
-export declare function ensureProjectArtifacts(args: EnsureProjectArtifactsArgs): Promise<ProjectArtifactsResult>;

package/dist/tool-module-import.d.ts

@@ -1,9 +0,0 @@
-/**
- * Dynamic import of another tool's library entry point (e.g.
- * `@uipath/solution-tool/init`).
- *
- * Its own module so tests can stand in for it, and so the specifier stays a
- * plain variable — bundlers then leave the `import()` to run at runtime
- * instead of inlining the multi-megabyte target bundle into the caller.
- */
-export declare function importToolModule(specifier: string): Promise<unknown>;