@uipath/tasks-tool 0.9.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/tasks-tool",
-    "version": "0.9.0",
+    "version": "1.0.0",
     "description": "Manage Action Center tasks.",
     "type": "module",
     "main": "./dist/tool.js",
@@ -18,15 +18,15 @@
         "lint:fix": "biome check --write ."
     },
     "devDependencies": {
-        "@types/node": "^25.5.0",
-        "@uipath/auth": "0.9.0",
-        "@uipath/common": "0.9.0",
-        "@uipath/uipath-typescript": "^1.3.1",
+        "@types/node": "^25.5.2",
+        "@uipath/auth": "1.0.0",
+        "@uipath/common": "1.0.0",
+        "@uipath/uipath-typescript": "^1.3.7",
         "commander": "^14.0.3",
-        "typescript": "^5"
+        "typescript": "^6.0.2"
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+    "gitHead": "d982977e86057fd9d0846c955595c64865aeecab"
 }

package/src/commands/tasks.spec.ts

@@ -36,6 +36,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             reassign: vi.fn().mockResolvedValue({ success: true, data: [] }),
             unassign: vi.fn().mockResolvedValue({ success: true, data: [] }),
             complete: vi.fn().mockResolvedValue({ success: true }),
+            getUsers: vi.fn().mockResolvedValue([]),
             ...overrides,
         },
     };
@@ -53,6 +54,7 @@ describe("tasks command registration", () => {
         expect(subcommands).toContain("reassign");
         expect(subcommands).toContain("unassign");
         expect(subcommands).toContain("complete");
+        expect(subcommands).toContain("users");
     });
 });
 
@@ -690,3 +692,173 @@ describe("tasks complete", () => {
         expect(process.exitCode).toBe(1);
     });
 });
+
+describe("tasks users", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should list users for a folder", async () => {
+        const users = [
+            { id: 1, name: "Alice", emailAddress: "alice@company.com" },
+            { id: 2, name: "Bob", emailAddress: "bob@company.com" },
+        ];
+        mockSdk({ getUsers: vi.fn().mockResolvedValue(users) });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "42"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "TaskUserList",
+                Data: users,
+            }),
+        );
+    });
+
+    it("should pass folder-id and pageSize to getUsers", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "42"]);
+
+        expect(sdk.tasks.getUsers).toHaveBeenCalledWith(
+            42,
+            expect.objectContaining({ pageSize: 100 }),
+        );
+    });
+
+    it("should pass tenant option", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "users",
+            "42",
+            "-t",
+            "MyTenant",
+        ]);
+
+        expect(createTasksClient).toHaveBeenCalledWith("MyTenant");
+    });
+
+    it("should reject invalid folder-id", async () => {
+        mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "abc"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining("<folder-id>"),
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should paginate through multiple pages", async () => {
+        const page1 = {
+            items: [{ id: 1, name: "Alice" }],
+            hasNextPage: true,
+            nextCursor: { value: "cursor-2" },
+        };
+        const page2 = {
+            items: [{ id: 2, name: "Bob" }],
+            hasNextPage: false,
+        };
+        const getUsersMock = vi
+            .fn()
+            .mockResolvedValueOnce(page1)
+            .mockResolvedValueOnce(page2);
+        mockSdk({ getUsers: getUsersMock });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "42"]);
+
+        expect(getUsersMock).toHaveBeenCalledTimes(2);
+        expect(getUsersMock).toHaveBeenLastCalledWith(
+            42,
+            expect.objectContaining({ cursor: { value: "cursor-2" } }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Code: "TaskUserList",
+                Data: [
+                    { id: 1, name: "Alice" },
+                    { id: 2, name: "Bob" },
+                ],
+            }),
+        );
+    });
+
+    it("should respect --limit option", async () => {
+        const page1 = {
+            items: [
+                { id: 1, name: "Alice" },
+                { id: 2, name: "Bob" },
+                { id: 3, name: "Carol" },
+            ],
+            hasNextPage: true,
+            nextCursor: { value: "cursor-2" },
+        };
+        mockSdk({ getUsers: vi.fn().mockResolvedValue(page1) });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "users",
+            "42",
+            "--limit",
+            "2",
+        ]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: [
+                    { id: 1, name: "Alice" },
+                    { id: 2, name: "Bob" },
+                ],
+            }),
+        );
+    });
+
+    it("should handle getUsers API error", async () => {
+        mockSdk({
+            getUsers: vi.fn().mockRejectedValue(new Error("Forbidden")),
+        });
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "42"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing task users",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should handle client connection error", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "users", "42"]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});

package/src/commands/tasks.ts

@@ -1,4 +1,5 @@
 import {
+    type CommandExample,
     catchError,
     extractErrorMessage,
     extractErrorMessageSync,
@@ -49,6 +50,56 @@ interface CompleteOptions {
     action?: string;
 }
 
+interface UsersOptions {
+    tenant?: string;
+    limit?: string;
+}
+
+const TASKS_USERS_EXAMPLES: CommandExample[] = [
+    {
+        Description: "List users with task permissions in a folder",
+        Command: "uip tasks users 42",
+        Output: {
+            Code: "TaskUserList",
+            Data: [
+                {
+                    id: 1,
+                    name: "Alice",
+                    surname: "Smith",
+                    userName: "alice",
+                    emailAddress: "alice@company.com",
+                    displayName: "Alice Smith",
+                },
+                {
+                    id: 2,
+                    name: "Bob",
+                    surname: "Jones",
+                    userName: "bob",
+                    emailAddress: "bob@company.com",
+                    displayName: "Bob Jones",
+                },
+            ],
+        },
+    },
+    {
+        Description: "Limit the number of users returned",
+        Command: "uip tasks users 42 --limit 10",
+        Output: {
+            Code: "TaskUserList",
+            Data: [
+                {
+                    id: 1,
+                    name: "Alice",
+                    surname: "Smith",
+                    userName: "alice",
+                    emailAddress: "alice@company.com",
+                    displayName: "Alice Smith",
+                },
+            ],
+        },
+    },
+];
+
 export const registerTasksCommand = (program: Command) => {
     program
         .command("list")
@@ -441,6 +492,107 @@ export const registerTasksCommand = (program: Command) => {
                 });
             },
         );
+
+    program
+        .command("users")
+        .description(
+            "List users with task permissions in a folder. Use the user ID with 'tasks assign'.",
+        )
+        .argument("<folder-id>", "Folder ID")
+        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .option(
+            "-l, --limit <number>",
+            "Maximum number of items to return (fetches all if omitted)",
+        )
+        .examples(TASKS_USERS_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (folderId: string, options: UsersOptions) => {
+                const [clientError, sdk] = await catchError(
+                    createTasksClient(options.tenant),
+                );
+
+                if (clientError) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: "Error connecting to Action Center",
+                        Instructions: await extractErrorMessage(clientError),
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                const parsedFolderId = parsePositiveInt(
+                    folderId,
+                    "<folder-id>",
+                );
+                if (!parsedFolderId.valid) {
+                    reportInvalidInt(parsedFolderId);
+                    return;
+                }
+
+                let limit: number | undefined;
+                if (options.limit) {
+                    const parsed = parsePositiveInt(options.limit, "--limit");
+                    if (!parsed.valid) {
+                        reportInvalidInt(parsed);
+                        return;
+                    }
+                    limit = parsed.value;
+                }
+
+                const allItems: unknown[] = [];
+                let cursor: { value: string } | undefined;
+
+                do {
+                    const getOptions: Record<string, unknown> = {
+                        pageSize: DEFAULT_PAGE_SIZE,
+                    };
+                    if (cursor) {
+                        getOptions.cursor = cursor;
+                    }
+
+                    const [usersError, result] = await catchError(
+                        sdk.tasks.getUsers(parsedFolderId.value, getOptions),
+                    );
+
+                    if (usersError) {
+                        OutputFormatter.error({
+                            Result: RESULTS.Failure,
+                            Message: "Error listing task users",
+                            Instructions: await extractErrorMessage(usersError),
+                        });
+                        processContext.exit(1);
+                        return;
+                    }
+
+                    if (Array.isArray(result)) {
+                        allItems.push(...result);
+                        break;
+                    }
+
+                    const page = result as unknown as Record<string, unknown>;
+                    const items = (page.items ?? []) as unknown[];
+                    allItems.push(...items);
+
+                    cursor = page.hasNextPage
+                        ? (page.nextCursor as { value: string })
+                        : undefined;
+
+                    if (limit && allItems.length >= limit) {
+                        break;
+                    }
+                } while (cursor);
+
+                const data = limit ? allItems.slice(0, limit) : allItems;
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: "TaskUserList",
+                    Data: data,
+                });
+            },
+        );
 };
 
 async function assignOrReassign(

package/tests/performance.e2e.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+const HELP_BUDGET_MS = 1_000;
+
+const manifest = readManifest<E2EManifest>(MANIFEST_PATH);
+const projectDir = manifest.sharedInstall.tempDir;
+
+describe("tasks performance", () => {
+    it(
+        `uip tasks -h completes within ${HELP_BUDGET_MS}ms`,
+        () => {
+            const start = performance.now();
+            localCliRaw(projectDir, "tasks -h");
+            expect(performance.now() - start).toBeLessThan(HELP_BUDGET_MS);
+        },
+        EXEC_TIMEOUT,
+    );
+});