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

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

@@ -7,6 +7,7 @@ import {
 import {
     EXEC_TIMEOUT,
     localCliRaw,
+    localCliRawWithArgs,
     parseOutput,
     readManifest,
 } from "../../../tests/e2e-shared/helpers";
@@ -49,14 +50,16 @@ describe("tasks users e2e", () => {
     }, EXEC_TIMEOUT);
 
     it(
-        "S1: missing folder-id argument fails fast",
+        "S1: missing folder fails loud when not interactive",
         () => {
             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/);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("A folder is required");
+            expect(res.Instructions).toMatch(/folder-id argument/);
+            expect(res.Instructions).toMatch(/--folder-path/);
+            expect(res.Instructions).not.toMatch(/--folder-id/);
         },
         EXEC_TIMEOUT,
     );
@@ -110,4 +113,55 @@ describe("tasks users e2e", () => {
         },
         EXEC_TIMEOUT,
     );
+
+    it(
+        "S5: lists users by folder path",
+        () => {
+            const foldersRaw = localCliRaw(
+                tempDir,
+                "or folders list --output json",
+            );
+            if (foldersRaw.exitCode !== 0) return;
+            const foldersRes = parseOutput(foldersRaw.stdout, "json") as {
+                Data?: { Path?: string; Name?: string }[];
+            };
+            const first = foldersRes.Data?.[0];
+            const path = first?.Path || first?.Name;
+            if (!path) return;
+
+            // API-derived value — pass as its own argument, never through a
+            // shell-interpolated string.
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "users",
+                "--folder-path",
+                path,
+                "--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(
+        "S6: the folder-id argument and folder options are mutually exclusive",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                "tasks users 42 --folder-path Shared --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).toBe(
+                "The folder-id argument cannot be used with --folder-path or --folder-key",
+            );
+        },
+        EXEC_TIMEOUT,
+    );
 });

package/tests/catalogs.e2e.test.ts

@@ -0,0 +1,393 @@
+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,
+    localCliRawWithArgs,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+interface Envelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+}
+
+interface Catalog {
+    Id?: number;
+    Name?: string;
+    Encrypted?: boolean;
+    RetentionAction?: string;
+    RetentionPeriod?: number;
+}
+
+interface TaskRow {
+    IsDeleted?: boolean;
+    Status?: string;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+function listTasks(asAdmin: boolean): TaskRow[] {
+    const flag = asAdmin ? "--as-admin " : "";
+    const raw = localCliRaw(
+        tempDir,
+        `tasks list ${flag}--limit 200 --output json`,
+    );
+    if (raw.exitCode !== 0) return [];
+    return (parseOutput(raw.stdout, "json") as { Data?: TaskRow[] }).Data ?? [];
+}
+
+function discoverFolderId(): string {
+    if (process.env.TASKS_TOOL_E2E_FOLDER_ID) {
+        return process.env.TASKS_TOOL_E2E_FOLDER_ID;
+    }
+    for (const asAdmin of [false, true]) {
+        const task = listTasks(asAdmin).find(
+            (t) => !t.IsDeleted && typeof t.FolderId === "number",
+        );
+        if (typeof task?.FolderId === "number") {
+            return String(task.FolderId);
+        }
+    }
+    throw new Error(
+        "No live task found to derive a folder for catalogs e2e. Set TASKS_TOOL_E2E_FOLDER_ID or seed a task.",
+    );
+}
+
+const folderId = discoverFolderId();
+let createdCatalogId: number | undefined;
+
+function createCatalog(name: string, extra: string[] = []): Envelope {
+    const raw = localCliRawWithArgs(tempDir, [
+        "tasks",
+        "catalogs",
+        "create",
+        "--folder-id",
+        folderId,
+        "--name",
+        name,
+        ...extra,
+        "--output",
+        "json",
+    ]);
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+function getCatalog(id: number): Envelope {
+    const raw = localCliRaw(
+        tempDir,
+        `tasks catalogs get ${id} --folder-id ${folderId} --output json`,
+    );
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+describe("tasks catalogs e2e", () => {
+    it(
+        "S1: list catalogs in a folder",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs list --folder-id ${folderId} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: list caps results with --limit",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs list --folder-id ${folderId} --limit 1 --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Code).toBe("TaskCatalogList");
+            expect((res.Data as unknown[]).length).toBeLessThanOrEqual(1);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: get a catalog by id",
+        () => {
+            const listRaw = localCliRaw(
+                tempDir,
+                `tasks catalogs list --folder-id ${folderId} --limit 1 --output json`,
+            );
+            const list = parseOutput(listRaw.stdout, "json") as {
+                Data?: Catalog[];
+            };
+            const id = list.Data?.[0]?.Id;
+            if (typeof id !== "number") {
+                throw new Error(
+                    "No catalog in the folder for getCatalogById. Seed a catalog first.",
+                );
+            }
+
+            const res = getCatalog(id);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogDetails");
+            expect((res.Data as Catalog).Id).toBe(id);
+            expect(typeof (res.Data as Catalog).Name).toBe("string");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: get a non-existent catalog reports a failure",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs get 999999999 --folder-id ${folderId} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error getting task catalog/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: invalid catalog id reports a validation error",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs get not-a-number --folder-id ${folderId} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid <id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S6: create a minimal catalog (name only)",
+        () => {
+            const name = `sdk-cli-e2e-${Date.now()}`;
+            const res = createCatalog(name);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogCreated");
+            const created = res.Data as Catalog;
+            expect(created.Name).toBe(name);
+            expect(typeof created.Id).toBe("number");
+            createdCatalogId = created.Id;
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: create a catalog with description, encryption, and a retention policy",
+        () => {
+            const name = `sdk-cli-e2e-ret-${Date.now()}`;
+            const res = createCatalog(name, [
+                "--description",
+                "Invoice approvals",
+                "--encrypted",
+                "--retention-action",
+                "Delete",
+                "--retention-period",
+                "30",
+            ]);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogCreated");
+            const created = res.Data as Catalog;
+            expect(created.Encrypted).toBe(true);
+            expect(created.RetentionAction).toBe("Delete");
+            expect(created.RetentionPeriod).toBe(30);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S8: create without --name fails",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs create --folder-id ${folderId} --output json`,
+            );
+            expect(raw.exitCode).not.toBe(0);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S9: create with an invalid --retention-action is rejected before the API call",
+        () => {
+            const res = createCatalog(`sdk-cli-e2e-bad-${Date.now()}`, [
+                "--retention-action",
+                "Purge",
+            ]);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("Invalid --retention-action 'Purge'");
+            expect(res.Instructions).toContain("Delete");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S10: update a catalog's name and description",
+        () => {
+            if (typeof createdCatalogId !== "number") {
+                throw new Error(
+                    "S6 must create a catalog before S10 updates it.",
+                );
+            }
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "catalogs",
+                "update",
+                String(createdCatalogId),
+                "--folder-id",
+                folderId,
+                "--name",
+                `sdk-cli-e2e-renamed-${Date.now()}`,
+                "--description",
+                "Updated",
+                "--output",
+                "json",
+            ]);
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogUpdated");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S11: retention round-trips through create, update, and get",
+        () => {
+            const name = `sdk-cli-e2e-rt-${Date.now()}`;
+            const created = createCatalog(name, [
+                "--retention-action",
+                "Delete",
+                "--retention-period",
+                "30",
+            ]);
+            const id = (created.Data as Catalog).Id;
+            expect(typeof id).toBe("number");
+
+            const afterCreate = getCatalog(id as number);
+            expect((afterCreate.Data as Catalog).RetentionPeriod).toBe(30);
+
+            const upd = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "catalogs",
+                "update",
+                String(id),
+                "--folder-id",
+                folderId,
+                "--name",
+                name,
+                "--retention-action",
+                "Delete",
+                "--retention-period",
+                "60",
+                "--output",
+                "json",
+            ]);
+            expect(upd.exitCode, upd.stdout).toBe(0);
+
+            const afterUpdate = getCatalog(id as number);
+            expect((afterUpdate.Data as Catalog).RetentionPeriod).toBe(60);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S12: update a non-existent catalog reports a failure",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs update 999999999 --folder-id ${folderId} --name whatever --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error updating task catalog/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S13: update with only --description preserves the other fields",
+        () => {
+            const name = `sdk-cli-e2e-merge-${Date.now()}`;
+            const created = createCatalog(name, [
+                "--retention-action",
+                "Delete",
+                "--retention-period",
+                "30",
+            ]);
+            const id = (created.Data as Catalog).Id;
+            expect(typeof id).toBe("number");
+
+            // Update only the description; leave name and retention unset.
+            const upd = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "catalogs",
+                "update",
+                String(id),
+                "--folder-id",
+                folderId,
+                "--description",
+                "Only this changed",
+                "--output",
+                "json",
+            ]);
+            expect(upd.exitCode, upd.stdout).toBe(0);
+
+            // Read-modify-write: name and retention must survive the update.
+            const after = getCatalog(id as number).Data as Catalog;
+            expect(after.Name).toBe(name);
+            expect(after.RetentionPeriod).toBe(30);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S14: list catalogs scoped by folder key",
+        () => {
+            const foldersRaw = localCliRaw(
+                tempDir,
+                "or folders list --output json",
+            );
+            if (foldersRaw.exitCode !== 0) return;
+            const foldersRes = parseOutput(foldersRaw.stdout, "json") as {
+                Data?: { Key?: string }[];
+            };
+            const key = foldersRes.Data?.[0]?.Key;
+            if (!key) return;
+
+            const raw = localCliRaw(
+                tempDir,
+                `tasks catalogs list --folder-key ${key} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCatalogList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/tests/comments.e2e.test.ts

@@ -0,0 +1,223 @@
+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,
+    localCliRawWithArgs,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+interface Envelope {
+    Result: string;
+    Code?: string;
+    Data?: unknown;
+    Message?: string;
+    Instructions?: string;
+}
+
+interface TaskRow {
+    Id?: number;
+    IsDeleted?: boolean;
+    Status?: string;
+    Type?: string;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+function listTasks(asAdmin: boolean): TaskRow[] {
+    const flag = asAdmin ? "--as-admin " : "";
+    const raw = localCliRaw(
+        tempDir,
+        `tasks list ${flag}--limit 200 --output json`,
+    );
+    if (raw.exitCode !== 0) return [];
+    return (parseOutput(raw.stdout, "json") as { Data?: TaskRow[] }).Data ?? [];
+}
+
+function discoverTask(): { taskId: string; folderId: string } | null {
+    const envFolder = process.env.TASKS_TOOL_E2E_FOLDER_ID;
+    const envTask =
+        process.env.TASKS_TOOL_E2E_TASK_ID_COMMENTS ??
+        process.env.TASKS_TOOL_E2E_TASK_ID;
+    if (envFolder && envTask) {
+        return { taskId: envTask, folderId: envFolder };
+    }
+    for (const asAdmin of [false, true]) {
+        const task = listTasks(asAdmin).find(
+            (t) =>
+                !t.IsDeleted &&
+                t.Status !== "Completed" &&
+                t.Type === "ExternalTask" &&
+                typeof t.Id === "number" &&
+                typeof t.FolderId === "number",
+        );
+        if (task) {
+            return {
+                taskId: String(task.Id),
+                folderId: String(envFolder ?? task.FolderId),
+            };
+        }
+    }
+    // No actionable ExternalTask on this tenant; skip the live suite (guarded by describe.skipIf below).
+    return null;
+}
+
+const discovered = discoverTask();
+const taskId = discovered?.taskId ?? "";
+const folderId = discovered?.folderId ?? "";
+
+describe.skipIf(!discovered)("tasks comments e2e", () => {
+    it(
+        "S1: list comments for a task",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks comments list ${taskId} --folder-id ${folderId} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCommentList");
+            expect(Array.isArray(res.Data)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: list caps results with --limit",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks comments list ${taskId} --folder-id ${folderId} --limit 1 --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Code).toBe("TaskCommentList");
+            expect((res.Data as unknown[]).length).toBeLessThanOrEqual(1);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: invalid task id reports a validation error",
+        () => {
+            const raw = localCliRaw(
+                tempDir,
+                `tasks comments list not-a-number --folder-id ${folderId} --output json`,
+            );
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid <task-id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: add a comment",
+        () => {
+            const text = `sdk-cli-e2e comment ${Date.now()}`;
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "comments",
+                "add",
+                taskId,
+                "--folder-id",
+                folderId,
+                "--text",
+                text,
+                "--output",
+                "json",
+            ]);
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode, JSON.stringify(res)).toBe(0);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskCommentCreated");
+            expect((res.Data as { Text?: string }).Text).toBe(text);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: empty text reports a validation error",
+        () => {
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "comments",
+                "add",
+                taskId,
+                "--folder-id",
+                folderId,
+                "--text",
+                "",
+                "--output",
+                "json",
+            ]);
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toBe("--text cannot be empty");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S6: add a comment to a non-existent task reports a failure",
+        () => {
+            const raw = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "comments",
+                "add",
+                "999999999",
+                "--folder-id",
+                folderId,
+                "--text",
+                "Escalated",
+                "--output",
+                "json",
+            ]);
+            const res = parseOutput(raw.stdout, "json") as Envelope;
+            expect(raw.exitCode).not.toBe(0);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error adding comment to task/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: a created comment appears in the list",
+        () => {
+            const marker = `sdk-cli-e2e-marker-${Date.now()}`;
+            const create = localCliRawWithArgs(tempDir, [
+                "tasks",
+                "comments",
+                "add",
+                taskId,
+                "--folder-id",
+                folderId,
+                "--text",
+                marker,
+                "--output",
+                "json",
+            ]);
+            expect(create.exitCode, create.stdout).toBe(0);
+
+            const listRaw = localCliRaw(
+                tempDir,
+                `tasks comments list ${taskId} --folder-id ${folderId} --limit 100 --output json`,
+            );
+            const list = parseOutput(listRaw.stdout, "json") as {
+                Data?: { Text?: string }[];
+            };
+            expect((list.Data ?? []).some((n) => n.Text === marker)).toBe(true);
+        },
+        EXEC_TIMEOUT,
+    );
+});