@uipath/function-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/tool.js

@@ -1,13 +1,20 @@
 import {
+  CommandDimensions,
   Option,
   OutputFormatter,
   RESULTS,
+  ScreenLogger,
+  ShipDimensions,
+  UIPATH_HOME_DIR,
+  catchError,
   createHiddenDeprecatedTenantOption,
+  getOutputFormat,
+  getOutputFormatExplicit,
   logger,
   processContext,
   stripHostGlobalOptions,
   trackShipSucceeded
-} from "./packager-tool-9331shqx.js";
+} from "./packager-tool-5s8z8be9.js";
 import {
   getFileSystem
 } from "./packager-tool-g0hcxnae.js";
@@ -19,7 +26,7 @@ var package_default = {
   name: "@uipath/function-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0-preview.212",
+  version: "1.204.0-preview.211",
   description: "UiPath CLI tool for JS/TS and Python Functions — thin passthrough to uipath-functions / uipath",
   keywords: [
     "uipcli-tool",
@@ -65,6 +72,7 @@ var package_default = {
     "@uipath/packager-tool-functions": "workspace:*",
     "@uipath/solution-sdk": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/uipath-python-bridge": "workspace:*",
     commander: "^14.0.3",
     "@types/bun": "^1.3.11"
   },
@@ -77,11 +85,37 @@ var package_default = {
 import { execSync } from "node:child_process";
 var fs = getFileSystem();
 function getCacheFilePath() {
-  return fs.path.join(fs.env.homedir(), ".uipcli", ".function-tool-cache.json");
+  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "functions-runtime-cache.json");
 }
 function registerSetupCommand(program) {
-  program.command("setup", { hidden: true }).description("Verify Node.js ≥20 is available (JS/TS projects only).").option("--force", "Force re-verification even if already cached", false).trackedAction(processContext, async (opts) => {
-    await ensureSetup({ force: opts.force, log: true });
+  program.command("setup").description("Verify the toolchains Functions needs: Node.js for JS/TS, Python and the 'uipath' package for Python.").option("--force", "Force re-verification even if already cached", false).trackedAction(processContext, async (opts) => {
+    if (!await ensureSetup({ force: opts.force, log: true })) {
+      return;
+    }
+    await reportPythonSetup(opts.force);
+    OutputFormatter.log({ Message: "Setup complete." });
+  });
+}
+async function reportPythonSetup(force) {
+  const { getAllowedPythonVersions, getPackageName, PythonService } = await import("./index-pv66qwr4.js");
+  const packageName = getPackageName();
+  const service = new PythonService({
+    allowedVersions: getAllowedPythonVersions(),
+    packageName,
+    toolName: "function"
+  });
+  const result = await service.setup(packageName, force);
+  if (result.success) {
+    OutputFormatter.log({
+      Message: `Python ${result.pythonVersion} with ${packageName} ${result.packageVersion} ✓`
+    });
+    return;
+  }
+  OutputFormatter.log({
+    Message: `Python: not configured. ${result.error ?? "Detection failed."}`
+  });
+  OutputFormatter.log({
+    Message: result.instructions ?? `Install a supported Python version and '${packageName}', then run 'uip function setup --force'. Python Functions commands fail until then; JS/TS is unaffected.`
   });
 }
 async function ensureSetup(opts = {}) {
@@ -116,7 +150,6 @@ async function ensureSetup(opts = {}) {
   await writeCache(cache);
   if (opts.log) {
     OutputFormatter.log({ Message: `Node.js ${nodeVersion} ✓` });
-    OutputFormatter.log({ Message: "Setup complete." });
   }
   return true;
 }
@@ -182,10 +215,9 @@ function namesRunTarget(arg) {
 }
 
 // src/services/utils.ts
-import { spawn } from "node:child_process";
 async function loadGlobalAuthEnv() {
   try {
-    const { loadEnvFileAsync, resolveEnvFilePathAsync } = await import("./index-t0pqjb4h.js");
+    const { loadEnvFileAsync, resolveEnvFilePathAsync } = await import("./index-hkrczw69.js");
     const { absolutePath } = await resolveEnvFilePathAsync();
     if (!absolutePath) {
       return {};
@@ -195,37 +227,6 @@ async function loadGlobalAuthEnv() {
     return {};
   }
 }
-async function spawnAndRelay(binary, args, cwd, extraEnv = {}) {
-  return new Promise((resolve) => {
-    const proc = spawn(binary, args, {
-      cwd,
-      env: {
-        ...process.env,
-        ...extraEnv
-      },
-      stdio: "inherit"
-    });
-    proc.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: `'${binary}' not found.`,
-          Instructions: "Install the Python CLI with 'pip install uipath' (or 'pipx install uipath')."
-        });
-      } else {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: err.message,
-          Instructions: "Run 'uip function setup' to verify your environment."
-        });
-      }
-      resolve(1);
-    });
-    proc.on("exit", (code) => {
-      resolve(code ?? 0);
-    });
-  });
-}
 
 // src/services/js-cli-runner.ts
 var fs2 = getFileSystem();
@@ -367,30 +368,129 @@ function flagsToDrop(verb) {
 }
 
 // src/services/python-cli-runner.ts
+async function runPythonCli(args, cwd, options = {}) {
+  const { runUipathPythonCommand } = await import("./index-pv66qwr4.js");
+  return runUipathPythonCommand(buildPythonArgs(args), {
+    cwd,
+    toolName: "function",
+    pinNewType: "function",
+    stdio: options.stdio ?? "inherit"
+  });
+}
+async function spawnPythonCli(args, cwd, options = {}) {
+  const { reportUipathPythonFailure } = await import("./index-pv66qwr4.js");
+  return reportUipathPythonFailure(await runPythonCli(args, cwd, options));
+}
+
+// src/services/run-envelope.ts
 var fs4 = getFileSystem();
-async function spawnPythonCli(args, cwd) {
-  const uipathExe = await resolveUipathPythonExe() ?? "uipath";
-  const { getAuthEnv } = await import("./index-t0pqjb4h.js");
-  const { authEnv, loginStatus } = await getAuthEnv();
-  if (!loginStatus) {
-    logger.debug("Auth unavailable, continuing without credentials.");
-  }
-  return spawnAndRelay(uipathExe, buildPythonArgs(args), cwd, authEnv);
-}
-async function resolveUipathPythonExe() {
-  const pythonCacheFile = fs4.path.join(fs4.env.homedir(), ".uipcli", ".codedagents-tool-cache.json");
-  if (await fs4.exists(pythonCacheFile)) {
-    try {
-      const content = await fs4.readFile(pythonCacheFile, "utf-8");
-      if (content) {
-        const cache = JSON.parse(content);
-        if (cache.uipathExePath && await fs4.exists(cache.uipathExePath)) {
-          return cache.uipathExePath;
-        }
-      }
-    } catch {}
+var ENVELOPE_FORMATS = new Set([
+  "json",
+  "yaml"
+]);
+var OUTPUT_FILE_FLAG = "--output-file";
+function wantsRunEnvelope(verb) {
+  return verb === "run" && getOutputFormatExplicit() && ENVELOPE_FORMATS.has(getOutputFormat());
+}
+async function runPythonWithEnvelope(args, cwd) {
+  const requestedFile = findOutputFile(args);
+  if (requestedFile !== undefined) {
+    return await runAndEmit(args, cwd, requestedFile);
+  }
+  const tempDir = await fs4.getTempDir();
+  const outputFile = fs4.path.join(tempDir, "output.json");
+  const exitCode = await runAndEmit([...args, OUTPUT_FILE_FLAG, outputFile], cwd, outputFile);
+  await catchError(fs4.rm(tempDir));
+  return exitCode;
+}
+async function runAndEmit(runArgs, cwd, outputFile) {
+  const [runError, result] = await catchError(runPythonCli(runArgs, cwd, { stdio: "stdout-to-stderr" }));
+  if (runError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      ErrorCode: "unknown_error",
+      Message: `Could not run the Python CLI: ${runError.message}`,
+      Instructions: "Run 'uip function setup' to check the environment, then re-run.",
+      Retry: "RetryWillNotFix"
+    });
+    return 1;
   }
-  return null;
+  if (!result.ok) {
+    return await reportRunFailure(result);
+  }
+  return await emitRunOutput(outputFile);
+}
+async function reportRunFailure(result) {
+  if (result.reason !== "command_failed") {
+    const { reportUipathPythonFailure } = await import("./index-pv66qwr4.js");
+    return reportUipathPythonFailure(result);
+  }
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    ErrorCode: "unknown_error",
+    Message: `The run exited with code ${result.exitCode}.`,
+    Instructions: "Read the error the run printed on stderr, fix what it names, then re-run 'uip function run'.",
+    Retry: "RetryWillNotFix"
+  });
+  return result.exitCode;
+}
+async function emitRunOutput(outputFile) {
+  if (!await fs4.exists(outputFile)) {
+    OutputFormatter.error({
+      Result: RESULTS.ConfigError,
+      ErrorCode: "configuration_error",
+      Message: `The run succeeded but wrote no output file at '${outputFile}'.`,
+      Instructions: "Update the Python CLI with 'pip install -U uipath' (or 'uv add -U uipath'), then re-run. Structured output needs a 'uipath' that supports '--output-file'.",
+      Retry: "RetryWillNotFix"
+    });
+    return 1;
+  }
+  const [readError, raw] = await catchError(fs4.readFile(outputFile, "utf-8"));
+  if (readError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      ErrorCode: "unknown_error",
+      Message: `Could not read the run's output file '${outputFile}': ${readError.message}`,
+      Instructions: "Check the path is readable, then re-run 'uip function run'.",
+      Retry: "RetryWillNotFix"
+    });
+    return 1;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(String(raw)));
+  if (parseError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      ErrorCode: "unknown_error",
+      Message: `The run's output file '${outputFile}' is not valid JSON: ${parseError.message}`,
+      Instructions: "Re-run 'uip function run' without '--output' to see the run's own output, and check the function returns a serialisable result.",
+      Retry: "RetryWillNotFix"
+    });
+    return 1;
+  }
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "RunComplete",
+    Data: asData(parsed)
+  }, { preserveDataKeys: true });
+  return 0;
+}
+function asData(parsed) {
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return { Output: parsed };
+}
+function findOutputFile(args) {
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === OUTPUT_FILE_FLAG) {
+      return args[i + 1] ?? "";
+    }
+    if (arg.startsWith(`${OUTPUT_FILE_FLAG}=`)) {
+      return arg.slice(OUTPUT_FILE_FLAG.length + 1);
+    }
+  }
+  return;
 }
 
 // src/services/dispatcher.ts
@@ -422,10 +522,10 @@ function trackShip(rawArgs) {
     return;
   }
   trackShipSucceeded({
-    ship_kind: ship.kind,
-    target: ship.target,
-    project_type: "coded_function",
-    command_name: `uip.function.${verb}`
+    [ShipDimensions.ShipKind]: ship.kind,
+    [ShipDimensions.Target]: ship.target,
+    [ShipDimensions.ProjectType]: "coded_function",
+    [CommandDimensions.CommandName]: `uip function ${verb}`
   });
 }
 async function dispatch(rawArgs) {
@@ -465,13 +565,17 @@ async function dispatch(rawArgs) {
       return;
     }
   }
+  const runEnvelope = wantsRunEnvelope(verb);
   switch (language) {
     case "python": {
-      const exitCode = await spawnPythonCli(args, cwd);
+      const exitCode = runEnvelope ? await runPythonWithEnvelope(args, cwd) : await spawnPythonCli(args, cwd);
       processContext.exit(exitCode);
       return;
     }
     case "javascript":
+      if (runEnvelope) {
+        ScreenLogger.progress("--output is not supported by 'run' on JS/TS projects yet; " + "the function's own output follows unchanged.");
+      }
       return runJsCli(args, cwd);
     case "unknown":
       if (verb === "new") {
@@ -488,7 +592,7 @@ async function dispatch(rawArgs) {
   }
 }
 async function reportSolutionRegistration(projectDir, skipSolutionRegistration) {
-  const { tryRegisterProjectInParentSolution } = await import("./index-v5xsxz9f.js");
+  const { tryRegisterProjectInParentSolution } = await import("./index-bpz85ayg.js");
   const registration = await tryRegisterProjectInParentSolution(fs5, projectDir, {
     skipRegistration: skipSolutionRegistration
   });
@@ -598,16 +702,16 @@ function registerPushCommand(program) {
 // src/commands/run.ts
 var FUNCTIONS_RUN_EXAMPLES = [
   {
-    Description: "Run the 'hello' function once with a JSON payload",
-    Command: `uip function run hello --input '{"name":"Ada"}'`,
+    Description: "Python project: run the 'hello' function once with a JSON payload and read the result as JSON",
+    Command: `uip function run hello --input '{"name":"Ada"}' --output json`,
     Output: {
       Code: "RunComplete",
       Data: { message: "Hello, Ada!" }
     }
   },
   {
-    Description: "Run a function with a payload kept in a file",
-    Command: "uip function run hello --input-file ./payload.json",
+    Description: "Python project: run a function with a payload kept in a file",
+    Command: "uip function run hello --input-file ./payload.json --output json",
     Output: {
       Code: "RunComplete",
       Data: { message: "Hello, Ada!" }
@@ -671,4 +775,4 @@ export {
   registerCommands
 };
 
-//# debugId=E13786D702BAAD3F64756E2164756E21
+//# debugId=8E6921E59020C95764756E2164756E21

package/package.json

@@ -2,7 +2,7 @@
     "name": "@uipath/function-tool",
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.203.0-preview.212",
+    "version": "1.204.0-preview.211",
     "description": "UiPath CLI tool for JS/TS and Python Functions — thin passthrough to uipath-functions / uipath",
     "keywords": [
         "uipcli-tool",
@@ -35,5 +35,5 @@
     "dependencies": {
         "typescript": "^5.7.0"
     },
-    "gitHead": "15094ce85cf76c59a54affbed3304febc271f41a"
+    "gitHead": "275e01f1f6098d4c3bc9673f5225f33372822534"
 }