@uipath/project-executor 1.200.0 → 1.201.0-preview.123

package/dist/index.js

@@ -1,7 +1,6 @@
 // src/models/run-options.ts
 var RunTarget;
 ((RunTarget2) => {
-  RunTarget2["Online"] = "Online";
   RunTarget2["Local"] = "Local";
 })(RunTarget ||= {});
 // src/models/run-status.ts
@@ -92,17 +91,23 @@ class RunResult {
     return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
   }
 }
-// src/services/executor-logger.ts
-var noopExecutorLogger = {
-  info: () => {},
-  warn: () => {},
-  error: () => {}
-};
+// src/services/executor-tool-import.ts
+async function importExecutorToolModule(specifier) {
+  try {
+    return { module: await import(specifier) };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
 // src/services/executor-tool-module.ts
 var EXECUTOR_FACTORY_EXPORT = "createExecutorFactory";
 function isExecutorFactoryModule(module) {
   return typeof module === "object" && module !== null && typeof module[EXECUTOR_FACTORY_EXPORT] === "function";
 }
+
 // src/services/executors-factory-repository.ts
 class ExecutorsFactoryRepository {
   factoryMap = new Map;
@@ -145,6 +150,46 @@ if (!_global[REGISTRY_KEY]) {
   _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
 }
 var executorsFactoryRepository = _global[REGISTRY_KEY];
+
+// src/services/executor-factory-provider.ts
+var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
+var _global2 = globalThis;
+function setExecutorFactoryProvider(provider) {
+  _global2[PROVIDER_KEY] = provider;
+}
+function clearExecutorFactoryProvider() {
+  _global2[PROVIDER_KEY] = undefined;
+}
+function registerExecutorFactoryFromModule(module, source) {
+  if (!isExecutorFactoryModule(module)) {
+    throw new Error(`${source} does not export ${EXECUTOR_FACTORY_EXPORT}().`);
+  }
+  const factory = module.createExecutorFactory();
+  executorsFactoryRepository.registerProjectExecutorFactory(factory);
+  return factory;
+}
+async function ensureExecutorFactory(verb, packageName) {
+  const provider = _global2[PROVIDER_KEY];
+  if (provider) {
+    await provider(verb);
+    return;
+  }
+  if (!packageName) {
+    throw new Error(`Running this project type needs the executor factory for '${verb}', and no package provides it.`);
+  }
+  const specifier = `${packageName}/executor-tool`;
+  const { module, error } = await importExecutorToolModule(specifier);
+  if (error) {
+    throw new Error(`Running this project type needs '${packageName}'. Install it.`, { cause: error });
+  }
+  registerExecutorFactoryFromModule(module, specifier);
+}
+// src/services/executor-logger.ts
+var noopExecutorLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
 // src/services/project-executor.ts
 class ProjectExecutor {
   fileSystem;
@@ -233,11 +278,15 @@ function messageOf(error) {
   return error instanceof Error ? error.message : String(error);
 }
 export {
+  setExecutorFactoryProvider,
+  registerExecutorFactoryFromModule,
   noopExecutorLogger,
   mapRunStatus,
   isTerminalRunStatus,
   isExecutorFactoryModule,
   executorsFactoryRepository,
+  ensureExecutorFactory,
+  clearExecutorFactoryProvider,
   TERMINAL_RUN_STATUSES,
   RunTarget,
   RunStatus,
@@ -249,4 +298,4 @@ export {
   EXECUTOR_FACTORY_EXPORT
 };
 
-//# debugId=F5B1472AD9D0537464756E2164756E21
+//# debugId=18288E109C30117964756E2164756E21

package/dist/src/index.d.ts

@@ -5,6 +5,8 @@ export type { RunStep } from "./models/run-result";
 export { RunErrorCode, RunResult } from "./models/run-result";
 export { isTerminalRunStatus, mapRunStatus, RunStatus, TERMINAL_RUN_STATUSES, } from "./models/run-status";
 export type { IProjectExecutorFactory } from "./services/executor-factory";
+export type { ExecutorFactoryProvider } from "./services/executor-factory-provider";
+export { clearExecutorFactoryProvider, ensureExecutorFactory, registerExecutorFactoryFromModule, setExecutorFactoryProvider, } from "./services/executor-factory-provider";
 export type { IExecutorLogger } from "./services/executor-logger";
 export { noopExecutorLogger } from "./services/executor-logger";
 export type { ExecutorFactoryModule } from "./services/executor-tool-module";

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

@@ -2,15 +2,21 @@ import type { ProjectType } from "./project-type";
 import type { RunStep } from "./run-result";
 import type { RunStatus } from "./run-status";
 /**
- * Where the run executes. Only `Online` is implemented today; the meeting
- * decision was online (serverless) first, with local/hybrid later, so the
- * enum exists to keep that choice explicit at the call site rather than
- * implied.
+ * Where the run executes.
+ *
+ * Legacy, and on its way out. Where a project runs is not a caller's choice but
+ * a fact about the project type — RPA drives the Studio on this machine, a
+ * low-code agent starts a serverless job because that is the only runtime that
+ * executes `agent.json` — so no caller has anything to decide here and
+ * `uip solution run` offers no flag for it.
+ *
+ * The field survives because the published RPA executor validates it, so callers
+ * still pass `Local` and it still means something to exactly one implementation.
+ * A newer executor ignores it. It becomes optional once no shipped executor
+ * checks it.
  */
 export declare enum RunTarget {
-    /** Serverless execution in the cloud. */
-    Online = "Online",
-    /** Local execution on the developer machine. Not implemented yet. */
+    /** Local execution on the developer machine. */
     Local = "Local"
 }
 /** Auth/tenant coordinates a project type needs to reach the backends. */

package/dist/src/services/executor-factory-provider.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Cross-module bridge for executor factory resolution.
+ *
+ * Mirrors `ensurePackagerFactory` in `@uipath/common`, and exists here rather
+ * than there for two reasons: `@uipath/common` has no dependencies by design,
+ * and registering an executor factory needs this package's registry and module
+ * guard. Everything about executors stays in the executor package.
+ */
+import type { IProjectExecutorFactory } from "./executor-factory";
+/**
+ * Makes the factory for a tool verb available, installing the tool if need be.
+ * The CLI registers one; a library caller has none.
+ */
+export type ExecutorFactoryProvider = (verb: string) => Promise<void>;
+export declare function setExecutorFactoryProvider(provider: ExecutorFactoryProvider): void;
+/** Clear the provider. Tests only. */
+export declare function clearExecutorFactoryProvider(): void;
+/**
+ * Narrow a dynamically imported `executor-tool` module and register the factory
+ * it supplies into the shared registry.
+ *
+ * This is the host half of the contract's split — a tool supplies a factory, the
+ * host decides what is registered — so it lives here where every host can reach
+ * it instead of being reimplemented per caller.
+ *
+ * @param source Where the module came from, named in the error when the export
+ * is missing so the failure points at a file rather than a type.
+ */
+export declare function registerExecutorFactoryFromModule(module: unknown, source: string): IProjectExecutorFactory;
+/**
+ * Ensure the executor factory for a tool verb is registered.
+ *
+ * Prefers the registered provider (installed by the CLI, which can also install
+ * the tool package). With no provider — a library caller — falls back to
+ * importing the tool package's own `executor-tool` entry point and registering
+ * what it supplies.
+ *
+ * @param verb CLI tool verb that owns the factory (e.g. `"rpa"`).
+ * @param packageName npm package behind that verb. Drives the fallback import
+ * and is the one thing the error asks for. Omit when unknown; there is then no
+ * fallback and no package to name.
+ */
+export declare function ensureExecutorFactory(verb: string, packageName?: string): Promise<void>;

package/dist/src/services/executor-tool-import.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dynamic import of a tool's `executor-tool` entry point.
+ *
+ * Its own module so tests can stand in for it, for the same reason
+ * `packager-tool-import.ts` is separate in `@uipath/common`: the real entry
+ * points are multi-megabyte tool bundles, and loading one takes seconds and
+ * blocks the event loop while it evaluates.
+ *
+ * Unlike the packager equivalent this is *not* a side-effect import. An
+ * `executor-tool` module registers nothing; it exports a factory supplier, so
+ * the caller gets the module back and decides what to register.
+ */
+/**
+ * Import `specifier` and hand back the module. Returns the failure instead of
+ * throwing so the caller can decide what to say.
+ */
+export declare function importExecutorToolModule(specifier: string): Promise<{
+    module?: unknown;
+    error?: Error;
+}>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/project-executor",
   "license": "MIT",
-  "version": "1.200.0",
+  "version": "1.201.0-preview.123",
   "description": "Common run contract implemented by every UiPath project type - the shared ProjectExecutor interface behind 'uip solution run'.",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "dist"
   ],
   "dependencies": {
-    "@uipath/filesystem": "1.200.0"
+    "@uipath/filesystem": "1.201.0"
   },
-  "gitHead": "173ad4b4930bd3e17a493b32e9f1c3c616ea1c10"
+  "gitHead": "0b5e086775b5974d9df45fc98f96f868bb3dda61"
 }