@uipath/packager-tool-flow 1.202.0 → 1.202.1

package/dist/flow-tool.d.ts

@@ -64,7 +64,13 @@ export declare class FlowTool extends ProjectTool {
      */
     private copyDirectoryContents;
     /**
-     * Create operate.json file if it doesn't already exist
+     * Create operate.json if it doesn't already exist, then stamp the runtime
+     * profile on it.
+     *
+     * Stamping here rather than where the artifacts are generated covers both
+     * writers: a project with no `.flow` skips artifact generation entirely and
+     * gets the scaffolded operate.json, which would otherwise ship with no
+     * profile for Orchestrator to read.
      */
     private createOperateFile;
     /**

package/dist/index.d.ts

@@ -5,5 +5,6 @@ export { createFlowRefResolver, type FlowIoLogger, migrateRawWorkflow, readFlowW
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
 export { type AgentInputVariable, hydrateInlineAgentInputVariables, isInlineAgentNodeType, readInlineAgentSource, reconcileInlineAgentInputVariables, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
+export { applyRuntimeProfile, isMaestroAutomateSentinel, RuntimeProfile, resolveRuntimeProfile, resolveRuntimeProfileForFlowFile, withRuntimeProfile, } from "./maestro-automate.js";
 export { operateRuntimeOptions } from "./operate-runtime-options.js";
 export { assertVoiceAgentDefinitionsEmbedded, type VoiceAgentFlowNode, voiceConvertOptions, } from "./voice-agent-definitions.js";

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   ensureProjectId,
   NugetConstants,
   NugetPackager,
-  Path as Path3,
+  Path as Path4,
   ProjectTool,
   ProjectTypes,
   TemporaryStorageService,
@@ -32,11 +32,12 @@ import {
 // package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.202.0",
+  version: "1.202.1",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./maestro-automate": "./dist/maestro-automate-entry.js"
   },
   repository: {
     type: "git",
@@ -48,7 +49,7 @@ var package_default = {
   },
   types: "./dist/index.d.ts",
   scripts: {
-    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --sourcemap=linked && tsc --emitDeclarationOnly --outDir dist",
+    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --sourcemap=linked && bun build ./src/maestro-automate-entry.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --sourcemap=linked && tsc --emitDeclarationOnly --outDir dist",
     dev: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --watch",
     test: "vitest run",
     "test:browser": "vitest run --config=vitest.browser.config.ts",
@@ -575,6 +576,53 @@ function setPublishIntentOnInlineAgents(fileFormat) {
   }
 }
 
+// src/maestro-automate.ts
+import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
+var SENTINEL_FILE_NAME = ".maestro_automate";
+var RuntimeProfile;
+((RuntimeProfile2) => {
+  RuntimeProfile2["Lite"] = "Lite";
+  RuntimeProfile2["Standard"] = "Standard";
+})(RuntimeProfile ||= {});
+async function applyRuntimeProfile(fs, projectDir, profile) {
+  const sentinel = Path3.join(projectDir, SENTINEL_FILE_NAME);
+  if (profile === "Lite" /* Lite */) {
+    await fs.writeFile(sentinel, "");
+    return;
+  }
+  if (await fs.exists(sentinel)) {
+    await fs.rm(sentinel);
+  }
+}
+async function resolveRuntimeProfile(fs, projectDir) {
+  const sentinel = Path3.join(projectDir, SENTINEL_FILE_NAME);
+  return await fs.exists(sentinel) ? "Lite" /* Lite */ : "Standard" /* Standard */;
+}
+function isMaestroAutomateSentinel(fileName) {
+  return fileName === SENTINEL_FILE_NAME;
+}
+var PROJECT_FILE_NAME = "project.uiproj";
+async function resolveRuntimeProfileForFlowFile(fs, flowFilePath) {
+  const flowDir = Path3.dirname(flowFilePath);
+  let dir = flowDir;
+  for (;; ) {
+    if (await fs.exists(Path3.join(dir, PROJECT_FILE_NAME))) {
+      return resolveRuntimeProfile(fs, dir);
+    }
+    const parent = Path3.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return resolveRuntimeProfile(fs, flowDir);
+}
+function withRuntimeProfile(operateJson, profile) {
+  return {
+    ...operateJson,
+    runtimeOptions: { ...operateJson.runtimeOptions, profile }
+  };
+}
+
 // src/operate-runtime-options.ts
 var CONVERSATION_TRIGGER_NODE_TYPE = "core.trigger.conversation";
 function operateRuntimeOptions(nodes) {
@@ -671,8 +719,8 @@ class FlowTool extends ProjectTool {
   }
   async buildAsync(options, _cancellationToken) {
     const tempFolder = await this._temporaryStorage.getTempFolderPath();
-    const localBuildFolder = Path3.join(tempFolder, NugetConstants.OutputFolderName);
-    const contentFolder = Path3.join(localBuildFolder, NugetConstants.ContentFolderName);
+    const localBuildFolder = Path4.join(tempFolder, NugetConstants.OutputFolderName);
+    const contentFolder = Path4.join(localBuildFolder, NugetConstants.ContentFolderName);
     try {
       this.logger.progress("Copying files...");
       await this.copyProjectFiles(options.projectPath, contentFolder);
@@ -681,10 +729,11 @@ class FlowTool extends ProjectTool {
       this.logger.progress("Resolving process bindings...");
       await this.resolveProcessBindings(contentFolder);
       const projectId = options.projectStorageId ?? await ensureProjectId(options.projectPath, this.fileSystem);
+      const profile = await resolveRuntimeProfile(this.fileSystem, options.projectPath);
       this.logger.progress("Generating packaging artifacts from .flow...");
       await this.generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents);
       this.logger.progress("Creating operate.json file...");
-      await this.createOperateFile(contentFolder, projectId);
+      await this.createOperateFile(contentFolder, projectId, profile);
       this.logger.progress("Creating package-descriptor.json file...");
       await this.createPackageDescriptor(localBuildFolder, contentFolder);
       return new ToolResult(ToolErrorCodes.Success, "done", [
@@ -705,7 +754,7 @@ class FlowTool extends ProjectTool {
     try {
       this.logger.progress("Creating NuGet package...");
       const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-      const nupkgPath = Path3.join(options.outputPath, nupkgFileName);
+      const nupkgPath = Path4.join(options.outputPath, nupkgFileName);
       const packager = new NugetPackager(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
       this.logger.progress("Package created successfully");
@@ -729,7 +778,7 @@ class FlowTool extends ProjectTool {
     const flowFile = entries.find((e) => e.endsWith(".flow"));
     if (!flowFile)
       return;
-    const flowPath = Path3.join(contentFolder, flowFile);
+    const flowPath = Path4.join(contentFolder, flowFile);
     const flowBuffer = await this.fileSystem.readFile(flowPath);
     if (!flowBuffer)
       return;
@@ -752,7 +801,7 @@ class FlowTool extends ProjectTool {
       this.logger.warn("No .flow file found in content folder — skipping artifact generation");
       return;
     }
-    const flowFilePath = Path3.join(contentFolder, flowFile);
+    const flowFilePath = Path4.join(contentFolder, flowFile);
     let workflow;
     try {
       workflow = await readFlowWorkflow(flowFilePath, {
@@ -766,7 +815,7 @@ class FlowTool extends ProjectTool {
     }
     await this.hydrateInlineAgentInputs(workflow, builtAgents, contentFolder);
     const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
-    const bpmnPath = Path3.join(contentFolder, bpmnFileName);
+    const bpmnPath = Path4.join(contentFolder, bpmnFileName);
     const fileFormat = inMemoryWorkflowToFileFormat(workflow);
     setPublishIntentOnInlineAgents(fileFormat);
     const resolvedFlowJson = JSON.stringify(fileFormat);
@@ -791,7 +840,7 @@ class FlowTool extends ProjectTool {
     const variables = workflow.variables ?? {};
     const bindings = workflow.bindings ?? [];
     const definitions = workflow.definitions ?? [];
-    const entryPointsPath = Path3.join(contentFolder, FlowConstants.EntryPointsFileName);
+    const entryPointsPath = Path4.join(contentFolder, FlowConstants.EntryPointsFileName);
     const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
     const agentEntryPoints = [];
     const seenSources = new Set;
@@ -832,11 +881,11 @@ class FlowTool extends ProjectTool {
     const allEntryPoints = [...entryPoints, ...agentEntryPoints];
     await this.fileSystem.writeFile(entryPointsPath, `${JSON.stringify(generateEntryPointsJson(allEntryPoints), null, 2)}
 `);
-    const bindingsPath = Path3.join(contentFolder, FlowConstants.BindingsV2FileName);
+    const bindingsPath = Path4.join(contentFolder, FlowConstants.BindingsV2FileName);
     const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
     await this.fileSystem.writeFile(bindingsPath, `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
 `);
-    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
+    const operatePath = Path4.join(contentFolder, NugetConstants.OperateFileName);
     const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
     const startEventId = startEventMatch?.[1] ?? "start";
     const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
@@ -865,7 +914,7 @@ class FlowTool extends ProjectTool {
     }, (source, added) => this.logger.info(`Reconciled ${added} inline-agent input(s) for "${source}" from agent.json inputSchema`), (source, reason) => this.logger.warn(reason === "invalid-source" ? `Inline agent "${source}" is not a bare project-id folder, so its inputs were not reconciled and packaging skips it — the agent would ship with no bound inputs.` : `Could not read an inputSchema for inline agent "${source}", so its inputs were not reconciled — the agent would ship with no bound inputs. Check that ${source}/agent.json exists and parses.`));
   }
   async readCopiedAgentJson(contentFolder, source) {
-    const agentJsonPath = Path3.join(contentFolder, source, "agent.json");
+    const agentJsonPath = Path4.join(contentFolder, source, "agent.json");
     if (!await this.fileSystem.exists(agentJsonPath)) {
       return;
     }
@@ -884,19 +933,19 @@ class FlowTool extends ProjectTool {
     await this.fileSystem.mkdir(contentFolder);
     const entries = await this.fileSystem.readdir(projectPath);
     for (const entry of entries) {
-      const sourceEntry = Path3.join(projectPath, entry);
+      const sourceEntry = Path4.join(projectPath, entry);
       const stat = await this.fileSystem.stat(sourceEntry);
       if (stat?.isDirectory()) {
         if (entry === NugetConstants.ContentFolderName) {
           await this.copyDirectoryContents(sourceEntry, contentFolder);
         }
       } else if (stat?.isFile()) {
-        if (entry === "project.uiproj") {
+        if (entry === "project.uiproj" || isMaestroAutomateSentinel(entry)) {
           continue;
         }
         const content = await this.fileSystem.readFile(sourceEntry);
         if (content) {
-          await this.fileSystem.writeFile(Path3.join(contentFolder, entry), content);
+          await this.fileSystem.writeFile(Path4.join(contentFolder, entry), content);
         }
       }
     }
@@ -905,8 +954,8 @@ class FlowTool extends ProjectTool {
     await this.fileSystem.mkdir(destinationPath);
     const entries = await this.fileSystem.readdir(sourcePath);
     for (const entry of entries) {
-      const sourceEntry = Path3.join(sourcePath, entry);
-      const destinationEntry = Path3.join(destinationPath, entry);
+      const sourceEntry = Path4.join(sourcePath, entry);
+      const destinationEntry = Path4.join(destinationPath, entry);
       const stat = await this.fileSystem.stat(sourceEntry);
       if (stat?.isDirectory()) {
         await this.copyDirectoryContents(sourceEntry, destinationEntry);
@@ -918,26 +967,43 @@ class FlowTool extends ProjectTool {
       }
     }
   }
-  async createOperateFile(contentFolder, projectId) {
+  async createOperateFile(contentFolder, projectId, profile) {
     await writeContentOperateFile(this.fileSystem, {
       contentFolder,
       projectId,
       contentType: ProjectTypes.Flow
     });
+    const operatePath = Path4.join(contentFolder, NugetConstants.OperateFileName);
+    const raw = await this.fileSystem.readFile(operatePath);
+    if (!raw)
+      return;
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let operateJson;
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("not a JSON object");
+      }
+      operateJson = parsed;
+    } catch (error) {
+      throw new Error(`Cannot set runtimeOptions.profile: ${NugetConstants.OperateFileName} is ` + `${error instanceof Error ? error.message : String(error)}. ` + "Fix or delete it and pack again; packaging regenerates a missing one.");
+    }
+    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(withRuntimeProfile(operateJson, profile), null, 2)}
+`);
   }
   async createPackageDescriptor(localBuildFolder, contentFolder) {
     const descriptorFiles = {};
-    descriptorFiles[NugetConstants.OperateFileName] = Path3.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
-    descriptorFiles[FlowConstants.EntryPointsFileName] = Path3.join(NugetConstants.ContentFolderName, FlowConstants.EntryPointsFileName);
-    descriptorFiles[NugetConstants.BindingsFileId] = Path3.join(NugetConstants.ContentFolderName, FlowConstants.BindingsV2FileName);
-    const contentEntries = await Path3.walkDirectory(this.fileSystem, contentFolder);
+    descriptorFiles[NugetConstants.OperateFileName] = Path4.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
+    descriptorFiles[FlowConstants.EntryPointsFileName] = Path4.join(NugetConstants.ContentFolderName, FlowConstants.EntryPointsFileName);
+    descriptorFiles[NugetConstants.BindingsFileId] = Path4.join(NugetConstants.ContentFolderName, FlowConstants.BindingsV2FileName);
+    const contentEntries = await Path4.walkDirectory(this.fileSystem, contentFolder);
     for (const entry of contentEntries) {
-      const ext = Path3.extname(entry.relativePath);
+      const ext = Path4.extname(entry.relativePath);
       if (ext === ".bpmn" || ext === ".flow") {
-        descriptorFiles[entry.relativePath] = Path3.join(NugetConstants.ContentFolderName, entry.relativePath);
+        descriptorFiles[entry.relativePath] = Path4.join(NugetConstants.ContentFolderName, entry.relativePath);
       }
     }
-    const packageDescriptorPath = Path3.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorPath = Path4.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
     const packageDescriptorJson = JSON.stringify({
       $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
       files: descriptorFiles
@@ -959,7 +1025,9 @@ toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 export {
   FlowTool,
   FlowToolFactory,
+  RuntimeProfile,
   SCHEMA_CONTAINER_MARKER,
+  applyRuntimeProfile,
   assertVoiceAgentDefinitionsEmbedded,
   buildInlineAgentContract,
   canonicalAgentInputPath,
@@ -967,6 +1035,7 @@ export {
   createFlowRefResolver,
   hydrateInlineAgentInputVariables,
   isInlineAgentNodeType,
+  isMaestroAutomateSentinel,
   leafToBinding,
   migrateRawWorkflow,
   operateRuntimeOptions,
@@ -975,9 +1044,12 @@ export {
   reconcileInlineAgentInputVariables,
   replaceExporterVersion,
   resolveAndMigrateWorkflow,
+  resolveRuntimeProfile,
+  resolveRuntimeProfileForFlowFile,
   resolveWorkflowRefs,
   setPublishIntentOnInlineAgents,
-  voiceConvertOptions
+  voiceConvertOptions,
+  withRuntimeProfile
 };
 
-//# debugId=A4A037706A114AA964756E2164756E21
+//# debugId=836D4B4DD546E6ED64756E2164756E21

package/dist/maestro-automate-entry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Side-effect-free entry for the Maestro Automate helpers.
+ *
+ * The package root registers `FlowToolFactory` with the global tool repository
+ * at module load, so importing it to read a profile pulls in the whole
+ * packager and mutates that registry. `flow init` only scaffolds files, and
+ * `@uipath/flow-tool/init` is a published API, so both take this entry
+ * instead.
+ */
+export { applyRuntimeProfile, isMaestroAutomateSentinel, RuntimeProfile, resolveRuntimeProfile, resolveRuntimeProfileForFlowFile, withRuntimeProfile, } from "./maestro-automate.js";

package/dist/maestro-automate-entry.js

@@ -0,0 +1,56 @@
+// src/maestro-automate.ts
+import { Path } from "@uipath/solutionpackager-tool-core";
+var SENTINEL_FILE_NAME = ".maestro_automate";
+var RuntimeProfile;
+((RuntimeProfile2) => {
+  RuntimeProfile2["Lite"] = "Lite";
+  RuntimeProfile2["Standard"] = "Standard";
+})(RuntimeProfile ||= {});
+async function applyRuntimeProfile(fs, projectDir, profile) {
+  const sentinel = Path.join(projectDir, SENTINEL_FILE_NAME);
+  if (profile === "Lite" /* Lite */) {
+    await fs.writeFile(sentinel, "");
+    return;
+  }
+  if (await fs.exists(sentinel)) {
+    await fs.rm(sentinel);
+  }
+}
+async function resolveRuntimeProfile(fs, projectDir) {
+  const sentinel = Path.join(projectDir, SENTINEL_FILE_NAME);
+  return await fs.exists(sentinel) ? "Lite" /* Lite */ : "Standard" /* Standard */;
+}
+function isMaestroAutomateSentinel(fileName) {
+  return fileName === SENTINEL_FILE_NAME;
+}
+var PROJECT_FILE_NAME = "project.uiproj";
+async function resolveRuntimeProfileForFlowFile(fs, flowFilePath) {
+  const flowDir = Path.dirname(flowFilePath);
+  let dir = flowDir;
+  for (;; ) {
+    if (await fs.exists(Path.join(dir, PROJECT_FILE_NAME))) {
+      return resolveRuntimeProfile(fs, dir);
+    }
+    const parent = Path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return resolveRuntimeProfile(fs, flowDir);
+}
+function withRuntimeProfile(operateJson, profile) {
+  return {
+    ...operateJson,
+    runtimeOptions: { ...operateJson.runtimeOptions, profile }
+  };
+}
+export {
+  RuntimeProfile,
+  applyRuntimeProfile,
+  isMaestroAutomateSentinel,
+  resolveRuntimeProfile,
+  resolveRuntimeProfileForFlowFile,
+  withRuntimeProfile
+};
+
+//# debugId=A6D16C6E2614839D64756E2164756E21

package/dist/maestro-automate.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Maestro Automate is a Flow project packed with a restricted runtime profile.
+ * It is not a separate project type: `contentType` stays `Flow` and the
+ * distinction travels as `runtimeOptions.profile` in operate.json, which
+ * Orchestrator reads off the package.
+ *
+ * Design time marks the project with a sentinel file rather than a field in
+ * `project.uiproj`, so the mark survives export, import, and projects authored
+ * outside Studio Web.
+ */
+import type { IFileSystem } from "@uipath/filesystem";
+/**
+ * `operate.json` → `runtimeOptions.profile`.
+ *
+ * Canonical PascalCase, like `contentType` beside it — Orchestrator matches
+ * these values exactly. These are wire values, not user-facing vocabulary:
+ * the CLI says `--automate` and maps to them, because the product does not
+ * brand the restricted profile "Lite".
+ */
+export declare enum RuntimeProfile {
+    Lite = "Lite",
+    Standard = "Standard"
+}
+interface OperateJson {
+    runtimeOptions?: Record<string, unknown>;
+}
+/**
+ * Make `projectDir`'s sentinel match `profile`.
+ *
+ * Symmetric on purpose: re-initializing a Lite project as Standard has to
+ * remove the sentinel, or packaging reads the stale file and ships Lite while
+ * operate.json says Standard.
+ */
+export declare function applyRuntimeProfile(fs: IFileSystem, projectDir: string, profile: RuntimeProfile): Promise<void>;
+/**
+ * The profile `projectDir` packs with. Resolve it per project directory —
+ * one solution can hold both Automate and standard Flow projects.
+ */
+export declare function resolveRuntimeProfile(fs: IFileSystem, projectDir: string): Promise<RuntimeProfile>;
+/** True for the sentinel, which packagers exclude from the package content. */
+export declare function isMaestroAutomateSentinel(fileName: string): boolean;
+/**
+ * The profile for the project owning `flowFilePath`.
+ *
+ * The flow's own directory is not the project root: `findProjectFlowFile`
+ * takes `project.uiproj`'s `MainFile` at any relative depth, and also accepts
+ * a `.flow` under `content/` or `flow_files/`. So this climbs to the nearest
+ * enclosing `project.uiproj` rather than assuming a depth or reading directory
+ * names — a fixed number of levels misses a nested `MainFile`, and matching on
+ * `content` misreads a project legitimately named that. Solutions are marked
+ * by a `.uipx`, so the nearest `project.uiproj` is the owning project and the
+ * climb cannot capture a sibling's sentinel.
+ *
+ * A `.flow` with no `project.uiproj` above it resolves from its own directory;
+ * `flow debug` accepts a loose file.
+ */
+export declare function resolveRuntimeProfileForFlowFile(fs: IFileSystem, flowFilePath: string): Promise<RuntimeProfile>;
+/**
+ * Stamp the profile onto an operate.json.
+ *
+ * `generateOperateJson` comes from `@uipath/flow-schema` and its options carry
+ * `isConversational` only, so the profile is merged in here. Keeping it out of
+ * that package also keeps this working across the flow-schema versions the
+ * release lines pin.
+ */
+export declare function withRuntimeProfile<T extends OperateJson>(operateJson: T, profile: RuntimeProfile): T;
+export {};

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.202.0",
+    "version": "1.202.1",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
-        ".": "./dist/index.js"
+        ".": "./dist/index.js",
+        "./maestro-automate": "./dist/maestro-automate-entry.js"
     },
     "repository": {
         "type": "git",
@@ -29,5 +30,5 @@
         "@uipath/solutionpackager-tool-core": "1.202.0",
         "@uipath/tool-agent": "^2.0.0"
     },
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "851398a44b9231a9fd8ac913a24388151bd27692"
 }