@uipath/tasks-tool 1.199.0 → 1.201.0-preview.115

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/tasks-tool",
   "license": "MIT",
-  "version": "1.199.0",
+  "version": "1.201.0-preview.115",
   "description": "Manage Action Center tasks.",
   "type": "module",
   "main": "./dist/tool.js",
@@ -14,5 +14,5 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
+  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
 }

package/src/commands/tasks.ts

@@ -22,6 +22,7 @@ const VALID_TASK_TYPES = [
     "DocumentValidationTask",
     "DocumentClassificationTask",
     "DataLabelingTask",
+    "QuickFormTask",
 ] as const;
 type ValidTaskType = (typeof VALID_TASK_TYPES)[number];
 
@@ -221,7 +222,7 @@ export const registerTasksCommand = (program: Command) => {
         )
         .option(
             "--task-type <type>",
-            "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask)",
+            "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask, QuickFormTask)",
         )
         .option(
             "--folder-id <id>",
@@ -397,7 +398,7 @@ export const registerTasksCommand = (program: Command) => {
         .argument("<task-id>", "Task ID")
         .requiredOption(
             "--type <type>",
-            "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask)",
+            "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask, QuickFormTask)",
         )
         .requiredOption("--folder-id <id>", "Folder ID (required)")
         .addOption(

package/tests/assign.e2e.test.ts

@@ -0,0 +1,166 @@
+import { RESULTS } from "@uipath/common";
+import { beforeAll, describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+// Scenario: scenarios/tasks-tool/assign.md
+// `uip tasks assign` / `reassign` / `unassign` — assignment lifecycle.
+
+interface AssignEnvelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+}
+
+// `tasks list`/`get` pass through the raw SDK task payload, which is
+// PascalCase (Id/FolderId/Status/...) — confirmed against a live tenant.
+interface TaskSummary {
+    Id?: number;
+    FolderId?: number;
+    Status?: string;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+describe("tasks assign e2e", () => {
+    let taskId: string | undefined;
+    let folderId: string | undefined;
+    let userIds: string[] = [];
+
+    beforeAll(() => {
+        // Fetch a batch and pick an actually-unassigned task — assigning an
+        // already-assigned task is a valid but different code path, and
+        // asserting `TaskAssigned` against it would be a flaky fixture choice.
+        const listRaw = localCliRaw(
+            tempDir,
+            "tasks list --limit 50 --output json",
+        );
+        if (listRaw.exitCode === 0) {
+            const listRes = parseOutput(listRaw.stdout, "json") as {
+                Data?: TaskSummary[];
+            };
+            const task = (listRes.Data ?? []).find(
+                (t) => t.Status === "Unassigned",
+            );
+            if (task?.Id !== undefined) {
+                taskId = String(task.Id);
+                folderId =
+                    task.FolderId !== undefined
+                        ? String(task.FolderId)
+                        : undefined;
+            }
+        }
+
+        if (folderId) {
+            const usersRaw = localCliRaw(
+                tempDir,
+                `tasks users ${folderId} --output json`,
+            );
+            if (usersRaw.exitCode === 0) {
+                // `tasks users` passes through the raw SDK payload, which is
+                // PascalCase (Id/Name/...) — unlike `tasks list`/`tasks get`,
+                // which return camelCase. Confirmed against a live tenant.
+                const usersRes = parseOutput(usersRaw.stdout, "json") as {
+                    Data?: Array<{ Id?: number; Type?: string }>;
+                };
+                userIds = (usersRes.Data ?? [])
+                    .filter((u) => u.Type === "DirectoryUser")
+                    .map((u) => u.Id)
+                    .filter((id): id is number => id !== undefined)
+                    .map(String);
+            }
+        }
+    }, EXEC_TIMEOUT);
+
+    // ── Deterministic (no tenant) ────────────────────────────────────────────
+
+    it(
+        "S1: assign without --user-id or --user is rejected",
+        () => {
+            const raw = localCliRaw(tempDir, "tasks assign 5 --output json");
+            expect(raw.exitCode).toBe(1);
+            const res = parseOutput(raw.stdout, "json") as AssignEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Missing assignee");
+            expect(res.Instructions).toBe(
+                "Provide either --user-id or --user to specify the assignee.",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: reassign without --user-id or --user is rejected",
+        () => {
+            const raw = localCliRaw(tempDir, "tasks reassign 5 --output json");
+            expect(raw.exitCode).toBe(1);
+            const res = parseOutput(raw.stdout, "json") as AssignEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Missing assignee");
+            expect(res.Instructions).toBe(
+                "Provide either --user-id or --user to specify the new assignee.",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── Tenant read/write (guarded — skip if the tenant has no usable fixture) ─
+
+    it(
+        "S3: assigns a task to a user by --user-id",
+        () => {
+            if (!taskId || userIds.length === 0) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks assign ${taskId} --user-id ${userIds[0]} --output json`,
+            );
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as AssignEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskAssigned");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: reassigns a task to a different user",
+        () => {
+            if (!taskId || userIds.length < 2) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks reassign ${taskId} --user-id ${userIds[1]} --output json`,
+            );
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as AssignEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskReassigned");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: unassign removes the assignee",
+        () => {
+            if (!taskId || userIds.length === 0) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks unassign ${taskId} --output json`,
+            );
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as AssignEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskUnassigned");
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/assignable-users.e2e.test.ts

@@ -0,0 +1,113 @@
+import { RESULTS } from "@uipath/common";
+import { beforeAll, describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+// Scenario: scenarios/tasks-tool/assignable-users.md
+// `uip tasks users <folder-id>` — discover assignable users in a folder.
+
+interface UsersEnvelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+    ErrorCode?: string;
+}
+
+// `tasks list` passes through the raw SDK task payload, which is
+// PascalCase (Id/FolderId/...) — confirmed against a live tenant.
+interface TaskSummary {
+    Id?: number;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+describe("tasks users e2e", () => {
+    let folderId: string | undefined;
+
+    beforeAll(() => {
+        const listRaw = localCliRaw(
+            tempDir,
+            "tasks list --limit 1 --output json",
+        );
+        if (listRaw.exitCode !== 0) return;
+        const listRes = parseOutput(listRaw.stdout, "json") as {
+            Data?: TaskSummary[];
+        };
+        const fid = listRes.Data?.[0]?.FolderId;
+        folderId = fid !== undefined ? String(fid) : undefined;
+    }, EXEC_TIMEOUT);
+
+    it(
+        "S1: missing folder-id argument fails fast",
+        () => {
+            const raw = localCliRaw(tempDir, "tasks users --output json");
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as UsersEnvelope;
+            expect(res.Result).toBe("ValidationError");
+            expect(res.ErrorCode).toBe("invalid_argument");
+            expect(res.Message).toMatch(/folder-id/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: lists users with task permissions in a folder",
+        () => {
+            if (!folderId) return; // no tenant task/folder to discover from
+            const raw = localCliRaw(
+                tempDir,
+                `tasks users ${folderId} --output json`,
+            );
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as UsersEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskUserList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: limits the number of returned users",
+        () => {
+            if (!folderId) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks users ${folderId} --limit 1 --output json`,
+            );
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as UsersEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskUserList");
+            expect((res.Data as unknown[]).length).toBeLessThanOrEqual(1);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: non-numeric folder-id is rejected",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks users not-a-number --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as UsersEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/Invalid <folder-id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/complete.e2e.test.ts

@@ -0,0 +1,207 @@
+import { RESULTS } from "@uipath/common";
+import { beforeAll, describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+// Scenario: scenarios/tasks-tool/complete.md
+// `uip tasks complete <task-id>` — completion with action and data.
+
+interface CompleteEnvelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+    ErrorCode?: string;
+}
+
+// `tasks list` passes through the raw SDK task payload, which is
+// PascalCase (Id/FolderId/Type/Status/...) — confirmed against a live tenant.
+interface TaskSummary {
+    Id?: number;
+    FolderId?: number;
+    Type?: string;
+    Status?: string;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+describe("tasks complete e2e", () => {
+    let formTaskId: string | undefined;
+    let formTaskFolderId: string | undefined;
+    let quickFormTaskId: string | undefined;
+    let quickFormTaskFolderId: string | undefined;
+
+    beforeAll(() => {
+        const listRaw = localCliRaw(tempDir, "tasks list --output json");
+        if (listRaw.exitCode !== 0) return;
+        const listRes = parseOutput(listRaw.stdout, "json") as {
+            Data?: TaskSummary[];
+        };
+        const tasks = listRes.Data ?? [];
+
+        const formTask = tasks.find(
+            (t) => t.Type === "FormTask" && t.Status !== "Completed",
+        );
+        if (formTask?.Id !== undefined) {
+            formTaskId = String(formTask.Id);
+            formTaskFolderId =
+                formTask.FolderId !== undefined
+                    ? String(formTask.FolderId)
+                    : undefined;
+        }
+
+        const quickFormTask = tasks.find(
+            (t) => t.Type === "QuickFormTask" && t.Status === "Pending",
+        );
+        if (quickFormTask?.Id !== undefined) {
+            quickFormTaskId = String(quickFormTask.Id);
+            quickFormTaskFolderId =
+                quickFormTask.FolderId !== undefined
+                    ? String(quickFormTask.FolderId)
+                    : undefined;
+        }
+    }, EXEC_TIMEOUT);
+
+    // ── Deterministic (no tenant) ────────────────────────────────────────────
+
+    it(
+        "S1: missing --type fails fast",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks complete 5 --folder-id 1 --output json",
+            );
+            expect(raw.exitCode).toBe(3);
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            expect(res.Result).toBe("ValidationError");
+            expect(res.ErrorCode).toBe("invalid_argument");
+            expect(res.Message).toBe(
+                "error: required option '--type <type>' not specified",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: missing --folder-id fails fast",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks complete 5 --type FormTask --output json",
+            );
+            expect(raw.exitCode).toBe(3);
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            expect(res.Result).toBe("ValidationError");
+            expect(res.ErrorCode).toBe("invalid_argument");
+            expect(res.Message).toBe(
+                "error: required option '--folder-id <id>' not specified",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── Tenant read (requires login) ─────────────────────────────────────────
+
+    it(
+        "S3: invalid task type value is rejected",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks complete 5 --type NotARealType --folder-id 1 --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid task type 'NotARealType'");
+            expect(res.Instructions).toMatch(/FormTask/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: invalid JSON in --data is rejected",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks complete 5 --type FormTask --folder-id 1 --data "{not json" --output json`,
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid JSON in --data");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // ── Tenant read/write (guarded — skip if no completable FormTask exists) ──
+    //
+    // The action/button name a FormTask actually accepts comes from its form
+    // layout definition, which `uip tasks` has no way to discover — `--action`
+    // is validated purely server-side against buttons this CLI can't inspect.
+    // Confirmed live: a task with a real FormLayoutId still rejected both
+    // "Approve" and "Submit" with "Provided form action does not match any
+    // button". So this scenario can only assert that a *wrong* action fails
+    // cleanly (already covered structurally) plus, opportunistically, that a
+    // guessed common action name either completes the task or fails with
+    // that specific button-mismatch message — never a connection/auth error.
+    it(
+        "S5: completes a task with an action and data",
+        () => {
+            if (!formTaskId || !formTaskFolderId) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks complete ${formTaskId} --type FormTask --folder-id ${formTaskFolderId} --action Submit --data "{}" --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            if (res.Result === RESULTS.Success) {
+                expect(raw.exitCode).toBe(0);
+                expect(res.Code).toBe("TaskCompleted");
+                return;
+            }
+            // No way to know this fixture's real button name — accept the
+            // known button-mismatch failure rather than asserting success.
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Instructions).toBe(
+                "Provided form action does not match any button",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+
+    // `QuickFormTask` (Maestro HITL QuickForm nodes) was previously missing
+    // from VALID_TASK_TYPES — completion was impossible for this type before
+    // this PR. "Submit" is the default single-outcome QuickForm action name;
+    // a QuickForm with custom outcomes would need a different name this CLI
+    // has no way to discover, so this scenario applies the same defensive
+    // accept-known-button-mismatch pattern as S5.
+    it(
+        "S6: completes a QuickFormTask",
+        () => {
+            if (!quickFormTaskId || !quickFormTaskFolderId) return;
+            const raw = localCliRaw(
+                tempDir,
+                `tasks complete ${quickFormTaskId} --type QuickFormTask --folder-id ${quickFormTaskFolderId} --action Submit --data "{}" --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as CompleteEnvelope;
+            if (res.Result === RESULTS.Success) {
+                expect(raw.exitCode).toBe(0);
+                expect(res.Code).toBe("TaskCompleted");
+                return;
+            }
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Instructions).toBe(
+                "Provided form action does not match any button",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/get.e2e.test.ts

@@ -0,0 +1,101 @@
+import { RESULTS } from "@uipath/common";
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+// Scenario: scenarios/tasks-tool/get.md
+// `uip tasks get <id>` — single task detail retrieval.
+
+interface GetEnvelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+    ErrorCode?: string;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+/** Discover a real task ID via `tasks list`, or undefined if the tenant has none. */
+function discoverTaskId(): string | undefined {
+    const raw = localCliRaw(tempDir, "tasks list --limit 1 --output json");
+    if (raw.exitCode !== 0) return undefined;
+    const res = parseOutput(raw.stdout, "json") as GetEnvelope;
+    // `tasks list` passes through the raw SDK task payload, which is
+    // PascalCase (Id/...) — confirmed against a live tenant.
+    const items = res.Data as Array<{ Id?: number }> | undefined;
+    const id = items?.[0]?.Id;
+    return typeof id === "number" ? String(id) : undefined;
+}
+
+describe("tasks get e2e", () => {
+    it(
+        "S1: missing id argument fails fast",
+        () => {
+            const raw = localCliRaw(tempDir, "tasks get --output json");
+            expect(raw.exitCode).toBe(3);
+            const res = parseOutput(raw.stdout, "json") as GetEnvelope;
+            expect(res.Result).toBe("ValidationError");
+            expect(res.ErrorCode).toBe("invalid_argument");
+            expect(res.Message).toBe("error: missing required argument 'id'");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: gets a task's details when one exists",
+        () => {
+            const id = discoverTaskId();
+            if (!id) return; // tenant has no tasks to fetch
+            const raw = localCliRaw(tempDir, `tasks get ${id} --output json`);
+            expect(raw.exitCode).toBe(0);
+            const res = parseOutput(raw.stdout, "json") as GetEnvelope;
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskDetails");
+            expect(res.Data).not.toBeNull();
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: unknown task id reports a clean not-found failure",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks get 999999999 --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as GetEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Error getting task '999999999'");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: --task-type without --folder-id is rejected",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks get 1 --task-type FormTask --output json",
+            );
+            expect(raw.exitCode).not.toBe(0);
+            const res = parseOutput(raw.stdout, "json") as GetEnvelope;
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe(
+                "--folder-id is required when --task-type is specified",
+            );
+            expect(res.Instructions).toMatch(/--folder-id/);
+        },
+        EXEC_TIMEOUT,
+    );
+});