@uipath/tasks-tool 1.201.0 → 1.202.0-preview.136

package/dist/tool.js

@@ -1,16 +1,13 @@
 import {
   metadata,
   registerCommands
-} from "./tool-mw0gkfep.js";
-import"./tool-rsk1xt86.js";
-import"./tool-9qecd4wb.js";
-import"./tool-7eva0peq.js";
-import"./tool-5arsyj36.js";
-import"./tool-r6rhp5ep.js";
-import"./tool-0v6na3yp.js";
+} from "./tool-p1m6mq0e.js";
+import"./tool-wfqnt43t.js";
+import"./tool-bndhpxxj.js";
+import"./tool-1de529jm.js";
 export {
-  registerCommands,
-  metadata
+  metadata,
+  registerCommands
 };
 
-//# debugId=106E34AF1A233DCE64756E2164756E21
+//# debugId=6DFACACDB904CB6164756E2164756E21

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@uipath/tasks-tool",
     "license": "MIT",
-    "version": "1.201.0",
+    "version": "1.202.0-preview.136",
     "description": "Manage Action Center tasks.",
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
@@ -14,5 +14,5 @@
     "bin": {
         "tasks-tool": "./dist/index.js"
     },
-    "gitHead": "7933378ad5276ac369900293a1447474dcec6826"
+    "gitHead": "f6270de2c7c04f4c43b2f5187b0c3d3c314c2610"
 }

package/src/commands/catalogs.ts

@@ -1,6 +1,6 @@
 import {
     catchError,
-    extractErrorMessage,
+    classifiedFailure,
     OutputFormatter,
     processContext,
     RESULTS,
@@ -67,11 +67,12 @@ export const registerCatalogsCommand = (program: Command) => {
                     taskCatalogs.getAll(getOptions),
                 );
                 if (listError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error listing task catalogs",
-                        Instructions: await extractErrorMessage(listError),
-                    });
+                    OutputFormatter.error(
+                        await classifiedFailure(
+                            "Error listing task catalogs",
+                            listError,
+                        ),
+                    );
                     processContext.exit(1);
                     return;
                 }
@@ -121,11 +122,12 @@ export const registerCatalogsCommand = (program: Command) => {
                 taskCatalogs.getById(parsedId, { folderId }),
             );
             if (getError) {
-                OutputFormatter.error({
-                    Result: RESULTS.Failure,
-                    Message: `Error getting task catalog '${id}'`,
-                    Instructions: await extractErrorMessage(getError),
-                });
+                OutputFormatter.error(
+                    await classifiedFailure(
+                        `Error getting task catalog '${id}'`,
+                        getError,
+                    ),
+                );
                 processContext.exit(1);
                 return;
             }
@@ -177,11 +179,12 @@ export const registerCatalogsCommand = (program: Command) => {
                     taskCatalogs.create(options.name, writeOptions),
                 );
                 if (createError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error creating task catalog '${options.name}'`,
-                        Instructions: await extractErrorMessage(createError),
-                    });
+                    OutputFormatter.error(
+                        await classifiedFailure(
+                            `Error creating task catalog '${options.name}'`,
+                            createError,
+                        ),
+                    );
                     processContext.exit(1);
                     return;
                 }
@@ -253,11 +256,12 @@ export const registerCatalogsCommand = (program: Command) => {
                     taskCatalogs.updateById(parsedId, writeOptions),
                 );
                 if (updateError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error updating task catalog '${id}'`,
-                        Instructions: await extractErrorMessage(updateError),
-                    });
+                    OutputFormatter.error(
+                        await classifiedFailure(
+                            `Error updating task catalog '${id}'`,
+                            updateError,
+                        ),
+                    );
                     processContext.exit(1);
                     return;
                 }

package/src/commands/tasks.spec.ts

@@ -1020,30 +1020,6 @@ describe("tasks catalogs list", () => {
             }),
         );
     });
-
-    it("should propagate API errors", async () => {
-        mockSdk();
-        mockCatalogs({
-            getAll: vi.fn().mockRejectedValue(new Error("boom")),
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "catalogs",
-            "list",
-            "--folder-id",
-            "42",
-        ]);
-
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error listing task catalogs",
-            }),
-        );
-    });
 });
 
 describe("tasks catalogs get", () => {
@@ -1103,31 +1079,6 @@ describe("tasks catalogs get", () => {
             }),
         );
     });
-
-    it("should propagate API errors", async () => {
-        mockSdk();
-        mockCatalogs({
-            getById: vi.fn().mockRejectedValue(new Error("not found")),
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "catalogs",
-            "get",
-            "7",
-            "--folder-id",
-            "42",
-        ]);
-
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error getting task catalog '7'",
-            }),
-        );
-    });
 });
 
 describe("tasks catalogs create", () => {
@@ -1322,30 +1273,109 @@ describe("tasks catalogs update", () => {
             }),
         );
     });
+});
 
-    it("should propagate API errors", async () => {
+// Every catalogs handler must classify a backend failure, so an agent can tell
+// "retry this" from "this will never work". Table-driven because the four
+// handlers differ only in the SDK method and the message they wrap it in.
+describe("tasks catalogs error classification", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    const HANDLERS = [
+        {
+            name: "list",
+            method: "getAll",
+            argv: ["catalogs", "list", "--folder-id", "42"],
+            message: "Error listing task catalogs",
+        },
+        {
+            name: "get",
+            method: "getById",
+            argv: ["catalogs", "get", "9", "--folder-id", "42"],
+            message: "Error getting task catalog '9'",
+        },
+        {
+            name: "create",
+            method: "create",
+            argv: [
+                "catalogs",
+                "create",
+                "--folder-id",
+                "42",
+                "--name",
+                "Invoices",
+            ],
+            message: "Error creating task catalog 'Invoices'",
+        },
+        {
+            name: "update",
+            method: "updateById",
+            argv: [
+                "catalogs",
+                "update",
+                "9",
+                "--folder-id",
+                "42",
+                "--name",
+                "Renamed",
+            ],
+            message: "Error updating task catalog '9'",
+        },
+    ];
+
+    async function runFailing(
+        method: string,
+        argv: string[],
+        error: unknown,
+    ): Promise<void> {
         mockSdk();
-        mockCatalogs({
-            updateById: vi.fn().mockRejectedValue(new Error("nope")),
-        });
+        mockCatalogs({ [method]: vi.fn().mockRejectedValue(error) });
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", ...argv]);
+    }
+
+    it.each(HANDLERS)("$name reports a transient 5xx as retryable", async ({
+        method,
+        argv,
+        message,
+    }) => {
+        await runFailing(
+            method,
+            argv,
+            Object.assign(new Error("Service Unavailable"), {
+                status: 503,
+            }),
+        );
 
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "catalogs",
-            "update",
-            "9",
-            "--folder-id",
-            "42",
-            "--name",
-            "Renamed",
-        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: message,
+                ErrorCode: "server_error",
+                Retry: "RetryLater",
+                Context: { httpStatus: 503 },
+            }),
+        );
+    });
+
+    // A non-HTTP failure carries no Context, which also exercises the other
+    // side of the `context ? { Context } : {}` spread in each handler.
+    it.each(HANDLERS)("$name reports a plain failure as non-retryable", async ({
+        method,
+        argv,
+        message,
+    }) => {
+        await runFailing(method, argv, new Error("boom"));
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "Error updating task catalog '9'",
+                Message: message,
+                ErrorCode: "unknown_error",
+                Retry: "RetryWillNotFix",
             }),
         );
     });

package/tests/catalogs.e2e.test.ts

@@ -18,6 +18,9 @@ interface Envelope {
     Data?: unknown;
     Message?: string;
     Instructions?: string;
+    ErrorCode?: string;
+    Retry?: string;
+    Context?: { httpStatus?: number };
 }
 
 interface Catalog {
@@ -90,6 +93,20 @@ function getCatalog(id: number): Envelope {
     return parseOutput(raw.stdout, "json") as Envelope;
 }
 
+/**
+ * A failure envelope built by `classifiedFailure()` carries the backend status
+ * through, so the error code comes from that status instead of falling back to
+ * the `unknown_error` default. The code is only asserted when the failure
+ * actually had an HTTP status — a network blip on the way to the tenant has
+ * none, and that is not what these scenarios pin.
+ */
+function expectClassified(res: Envelope): void {
+    expect(res.Retry).toBeDefined();
+    if (res.Context?.httpStatus !== undefined) {
+        expect(res.ErrorCode).not.toBe("unknown_error");
+    }
+}
+
 describe("tasks catalogs e2e", () => {
     it(
         "S1: list catalogs in a folder",
@@ -159,6 +176,7 @@ describe("tasks catalogs e2e", () => {
             expect(raw.exitCode).not.toBe(0);
             expect(res.Result).toBe(RESULTS.Failure);
             expect(res.Message).toMatch(/^Error getting task catalog/);
+            expectClassified(res);
         },
         EXEC_TIMEOUT,
     );
@@ -324,6 +342,7 @@ describe("tasks catalogs e2e", () => {
             expect(raw.exitCode).not.toBe(0);
             expect(res.Result).toBe(RESULTS.Failure);
             expect(res.Message).toMatch(/^Error updating task catalog/);
+            expectClassified(res);
         },
         EXEC_TIMEOUT,
     );
@@ -390,4 +409,10 @@ describe("tasks catalogs e2e", () => {
         },
         EXEC_TIMEOUT,
     );
+
+    // A 5xx from the catalogs endpoint cannot be induced against a live tenant,
+    // so the RetryLater classification is unit-covered in tasks.spec.ts instead.
+    // Expected envelope on an HTTP 5xx from any catalogs call: Result: Failure,
+    // ErrorCode: server_error, Retry: RetryLater, Context.httpStatus: 5xx.
+    it.skip("S15: a transient catalogs failure is reported as retryable", () => {});
 });

package/dist/browser-strategy-yccf8mtd.js

@@ -1,99 +0,0 @@
-import {
-  getGlobalThis
-} from "./tool-9qecd4wb.js";
-import {
-  AUTH_CANCELLED_ERROR_CODE
-} from "./tool-5arsyj36.js";
-import"./tool-0v6na3yp.js";
-
-// ../auth/src/strategies/browser-strategy.ts
-class BrowserAuthStrategy {
-  async execute(url, _redirectUri, expectedState, opts) {
-    const global = getGlobalThis();
-    if (!global?.window) {
-      throw new Error("Browser environment required for authentication");
-    }
-    const screenWidth = global.window.screen?.width ?? 1024;
-    const screenHeight = global.window.screen?.height ?? 768;
-    const width = 600;
-    const height = 700;
-    const left = screenWidth / 2 - width / 2;
-    const top = screenHeight / 2 - height / 2;
-    if (!global.window.open) {
-      throw new Error("window.open is not available");
-    }
-    const popupResult = global.window.open(url, "uip_auth", `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`);
-    const popup = popupResult;
-    if (!popup) {
-      throw new Error(`Authentication popup was blocked by your browser.
-
-` + `To continue:
-` + `1. Look for a popup blocker icon in your address bar
-` + `2. Allow popups for this site
-` + `3. Try logging in again
-
-` + "If using an ad blocker, you may need to temporarily disable it.");
-    }
-    return new Promise((resolve, reject) => {
-      let timer;
-      const messageHandler = (event) => {
-        if (event.data?.type === "UIP_AUTH_CODE" && event.data.code) {
-          if (event.data.state !== expectedState) {
-            cleanup();
-            reject(new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again."));
-            popup.close();
-            return;
-          }
-          cleanup();
-          resolve(event.data.code);
-          popup.close();
-        } else if (event.data?.type === "UIP_AUTH_ERROR") {
-          cleanup();
-          const errorMsg = event.data.error || "Authentication failed";
-          reject(new Error(`Authentication failed: ${errorMsg}
-
-` + "Please check your credentials and try again. " + "If the problem persists, verify your UiPath account is active."));
-          popup.close();
-        }
-      };
-      const cleanup = () => {
-        global.window?.removeEventListener?.("message", messageHandler);
-        opts?.signal?.removeEventListener("abort", onAbort);
-        if (timer)
-          clearInterval(timer);
-      };
-      const onAbort = () => {
-        cleanup();
-        const err = new Error(`Authentication was cancelled.
-
-` + "The sign-in was cancelled before completing the login process. " + "Please try again and complete the authentication flow.");
-        err.code = AUTH_CANCELLED_ERROR_CODE;
-        reject(err);
-        popup.close();
-      };
-      if (opts?.signal) {
-        if (opts.signal.aborted) {
-          onAbort();
-          return;
-        }
-        opts.signal.addEventListener("abort", onAbort, { once: true });
-      }
-      if (global.window?.addEventListener) {
-        global.window.addEventListener("message", messageHandler);
-      }
-      timer = setInterval(() => {
-        if (popup.closed) {
-          cleanup();
-          reject(new Error(`Authentication was cancelled.
-
-` + "The authentication popup was closed before completing the login process. " + "Please try again and complete the authentication flow."));
-        }
-      }, 1000);
-    });
-  }
-}
-export {
-  BrowserAuthStrategy
-};
-
-//# debugId=B13A3005E9EE6C6564756E2164756E21