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

package/src/commands/catalogs.ts

@@ -0,0 +1,277 @@
+import {
+    catchError,
+    extractErrorMessage,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { Command } from "commander";
+
+import { createTaskCatalogsClient } from "../utils/sdk-client";
+import {
+    buildCatalogCreateOptions,
+    buildCatalogUpdateOptions,
+    type CatalogCreateOptions,
+    type CatalogGetOptions,
+    type CatalogListOptions,
+    type CatalogUpdateOptions,
+} from "./_shared/catalog-options";
+import { connectTasksClient } from "./_shared/connect";
+import { DEFAULT_PAGE_SIZE } from "./_shared/constants";
+import {
+    addFolderScopeOptions,
+    resolveFolderId,
+} from "./_shared/folder-picker";
+import { parseIntArg } from "./_shared/parse";
+
+export const registerCatalogsCommand = (program: Command) => {
+    const catalogs = program
+        .command("catalogs")
+        .description("Manage task catalogs");
+
+    addFolderScopeOptions(
+        catalogs.command("list").description("List task catalogs in a folder"),
+    )
+        .option(
+            "-l, --limit <number>",
+            "Maximum number of items to return (fetches all if omitted)",
+        )
+        .trackedAction(processContext, async (options: CatalogListOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            let limit: number | undefined;
+            if (options.limit) {
+                const parsed = parseIntArg(options.limit, "--limit");
+                if (parsed === null) return;
+                limit = parsed;
+            }
+
+            const taskCatalogs = createTaskCatalogsClient(sdk);
+            const allItems: unknown[] = [];
+            let cursor: { value: string } | undefined;
+
+            do {
+                const getOptions: Record<string, unknown> = {
+                    folderId,
+                    pageSize: DEFAULT_PAGE_SIZE,
+                };
+                if (cursor) {
+                    getOptions.cursor = cursor;
+                }
+
+                const [listError, result] = await catchError(
+                    taskCatalogs.getAll(getOptions),
+                );
+                if (listError) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: "Error listing task catalogs",
+                        Instructions: await extractErrorMessage(listError),
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                if (Array.isArray(result)) {
+                    allItems.push(...result);
+                    break;
+                }
+
+                const page = result as unknown as Record<string, unknown>;
+                allItems.push(...((page.items ?? []) as unknown[]));
+                cursor = page.hasNextPage
+                    ? (page.nextCursor as { value: string })
+                    : undefined;
+
+                if (limit && allItems.length >= limit) {
+                    break;
+                }
+            } while (cursor);
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskCatalogList",
+                Data: limit ? allItems.slice(0, limit) : allItems,
+            });
+        });
+
+    addFolderScopeOptions(
+        catalogs
+            .command("get")
+            .description("Get a task catalog by ID")
+            .argument("<id>", "Task catalog ID"),
+    ).trackedAction(
+        processContext,
+        async (id: string, options: CatalogGetOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const parsedId = parseIntArg(id, "<id>");
+            if (parsedId === null) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            const taskCatalogs = createTaskCatalogsClient(sdk);
+            const [getError, catalog] = await catchError(
+                taskCatalogs.getById(parsedId, { folderId }),
+            );
+            if (getError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: `Error getting task catalog '${id}'`,
+                    Instructions: await extractErrorMessage(getError),
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskCatalogDetails",
+                Data: catalog,
+            });
+        },
+    );
+
+    addFolderScopeOptions(
+        catalogs
+            .command("create")
+            .description("Create a task catalog in a folder")
+            .requiredOption("--name <name>", "Catalog name (required)"),
+    )
+        .option("--description <text>", "Catalog description")
+        .option("--encrypted", "Encrypt the data of tasks in this catalog")
+        .option(
+            "--retention-action <action>",
+            "Action at the retention limit (Delete, Archive)",
+        )
+        .option("--retention-period <days>", "Retention period in days")
+        .option(
+            "--retention-bucket-id <id>",
+            "Storage bucket ID (used when retention action is Archive)",
+        )
+        .trackedAction(
+            processContext,
+            async (options: CatalogCreateOptions) => {
+                const sdk = await connectTasksClient();
+                if (!sdk) return;
+
+                const folderId = await resolveFolderId(options);
+                if (folderId === null) return;
+
+                const writeOptions = buildCatalogCreateOptions(
+                    options,
+                    folderId,
+                );
+                if (!writeOptions) {
+                    return;
+                }
+
+                const taskCatalogs = createTaskCatalogsClient(sdk);
+                const [createError, catalog] = await catchError(
+                    taskCatalogs.create(options.name, writeOptions),
+                );
+                if (createError) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: `Error creating task catalog '${options.name}'`,
+                        Instructions: await extractErrorMessage(createError),
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: "TaskCatalogCreated",
+                    Data: catalog,
+                });
+            },
+        );
+
+    addFolderScopeOptions(
+        catalogs
+            .command("update")
+            .description("Update a task catalog")
+            .argument("<id>", "Task catalog ID"),
+    )
+        .option("--name <name>", "New catalog name")
+        .option("--description <text>", "Catalog description")
+        .option(
+            "--retention-action <action>",
+            "Action at the retention limit (Delete, Archive)",
+        )
+        .option("--retention-period <days>", "Retention period in days")
+        .option(
+            "--retention-bucket-id <id>",
+            "Storage bucket ID (used when retention action is Archive)",
+        )
+        .trackedAction(
+            processContext,
+            async (id: string, options: CatalogUpdateOptions) => {
+                const sdk = await connectTasksClient();
+                if (!sdk) return;
+
+                const parsedId = parseIntArg(id, "<id>");
+                if (parsedId === null) return;
+
+                const hasUpdate =
+                    options.name !== undefined ||
+                    options.description !== undefined ||
+                    options.retentionAction !== undefined ||
+                    options.retentionPeriod !== undefined ||
+                    options.retentionBucketId !== undefined;
+                if (!hasUpdate) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: "No catalog changes provided",
+                        Instructions:
+                            "Pass at least one of --name, --description, --retention-action, --retention-period, or --retention-bucket-id.",
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                const folderId = await resolveFolderId(options);
+                if (folderId === null) return;
+
+                const writeOptions = buildCatalogUpdateOptions(
+                    options,
+                    folderId,
+                );
+                if (!writeOptions) {
+                    return;
+                }
+
+                const taskCatalogs = createTaskCatalogsClient(sdk);
+                const [updateError] = await catchError(
+                    taskCatalogs.updateById(parsedId, writeOptions),
+                );
+                if (updateError) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: `Error updating task catalog '${id}'`,
+                        Instructions: await extractErrorMessage(updateError),
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: "TaskCatalogUpdated",
+                    Data: {
+                        id: parsedId,
+                        ...(options.name !== undefined
+                            ? { name: options.name }
+                            : {}),
+                    },
+                });
+            },
+        );
+};

package/src/commands/comments.ts

@@ -0,0 +1,160 @@
+import {
+    catchError,
+    extractErrorMessage,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { Command } from "commander";
+
+import { connectTasksClient } from "./_shared/connect";
+import { DEFAULT_PAGE_SIZE } from "./_shared/constants";
+import {
+    addFolderScopeOptions,
+    type FolderScopeOptions,
+    resolveFolderId,
+} from "./_shared/folder-picker";
+import { parseIntArg } from "./_shared/parse";
+
+interface CommentListOptions extends FolderScopeOptions {
+    limit?: string;
+}
+
+interface CommentCreateOptions extends FolderScopeOptions {
+    text: string;
+}
+
+export const registerCommentsCommand = (program: Command) => {
+    const comments = program
+        .command("comments")
+        .description("Manage task comments");
+
+    addFolderScopeOptions(
+        comments
+            .command("list")
+            .description("List the comments on a task")
+            .argument("<task-id>", "Task ID"),
+    )
+        .option(
+            "-l, --limit <number>",
+            "Maximum number of items to return (fetches all if omitted)",
+        )
+        .trackedAction(
+            processContext,
+            async (taskId: string, options: CommentListOptions) => {
+                const sdk = await connectTasksClient();
+                if (!sdk) return;
+
+                const parsedTaskId = parseIntArg(taskId, "<task-id>");
+                if (parsedTaskId === null) return;
+
+                const folderId = await resolveFolderId(options);
+                if (folderId === null) return;
+
+                let limit: number | undefined;
+                if (options.limit) {
+                    const parsed = parseIntArg(options.limit, "--limit");
+                    if (parsed === null) return;
+                    limit = parsed;
+                }
+
+                const allItems: unknown[] = [];
+                let cursor: { value: string } | undefined;
+
+                do {
+                    const getOptions: Record<string, unknown> = {
+                        folderId,
+                        pageSize: DEFAULT_PAGE_SIZE,
+                    };
+                    if (cursor) {
+                        getOptions.cursor = cursor;
+                    }
+
+                    const [listError, result] = await catchError(
+                        sdk.tasks.getComments(parsedTaskId, getOptions),
+                    );
+                    if (listError) {
+                        OutputFormatter.error({
+                            Result: RESULTS.Failure,
+                            Message: "Error listing task comments",
+                            Instructions: await extractErrorMessage(listError),
+                        });
+                        processContext.exit(1);
+                        return;
+                    }
+
+                    if (Array.isArray(result)) {
+                        allItems.push(...result);
+                        break;
+                    }
+
+                    const page = result as unknown as Record<string, unknown>;
+                    allItems.push(...((page.items ?? []) as unknown[]));
+                    cursor = page.hasNextPage
+                        ? (page.nextCursor as { value: string })
+                        : undefined;
+
+                    if (limit && allItems.length >= limit) {
+                        break;
+                    }
+                } while (cursor);
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: "TaskCommentList",
+                    Data: limit ? allItems.slice(0, limit) : allItems,
+                });
+            },
+        );
+
+    addFolderScopeOptions(
+        comments
+            .command("add")
+            .description("Add a comment to a task")
+            .argument("<task-id>", "Task ID")
+            .requiredOption("--text <text>", "Comment text (required)"),
+    ).trackedAction(
+        processContext,
+        async (taskId: string, options: CommentCreateOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const parsedTaskId = parseIntArg(taskId, "<task-id>");
+            if (parsedTaskId === null) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            if (!options.text) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: "--text cannot be empty",
+                    Instructions: "Provide comment text with --text <text>.",
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            const [createError, comment] = await catchError(
+                sdk.tasks.createComment(parsedTaskId, options.text, {
+                    folderId,
+                }),
+            );
+            if (createError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: `Error adding comment to task '${taskId}'`,
+                    Instructions: await extractErrorMessage(createError),
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskCommentCreated",
+                Data: comment,
+            });
+        },
+    );
+};

package/src/commands/data.ts

@@ -0,0 +1,137 @@
+import {
+    catchError,
+    extractErrorMessage,
+    extractErrorMessageSync,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { Command } from "commander";
+
+import { connectTasksClient } from "./_shared/connect";
+import {
+    addFolderScopeOptions,
+    type FolderScopeOptions,
+    resolveFolderId,
+} from "./_shared/folder-picker";
+import { parseIntArg } from "./_shared/parse";
+
+type DataGetOptions = FolderScopeOptions;
+
+interface DataSaveOptions extends FolderScopeOptions {
+    data: string;
+}
+
+export const registerDataCommand = (program: Command) => {
+    const data = program.command("data").description("Manage task data");
+
+    addFolderScopeOptions(
+        data
+            .command("get")
+            .description("Get a task's data")
+            .argument("<task-id>", "Task ID"),
+    ).trackedAction(
+        processContext,
+        async (taskId: string, options: DataGetOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const parsedTaskId = parseIntArg(taskId, "<task-id>");
+            if (parsedTaskId === null) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            const [getError, task] = await catchError(
+                sdk.tasks.getDataById(parsedTaskId, { folderId }),
+            );
+            if (getError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: `Error getting data for task '${taskId}'`,
+                    Instructions: await extractErrorMessage(getError),
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskData",
+                Data: task,
+            });
+        },
+    );
+
+    addFolderScopeOptions(
+        data
+            .command("save")
+            .description("Save a task's data")
+            .argument("<task-id>", "Task ID")
+            .requiredOption("--data <json>", "Task data as a JSON object"),
+    ).trackedAction(
+        processContext,
+        async (taskId: string, options: DataSaveOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const parsedTaskId = parseIntArg(taskId, "<task-id>");
+            if (parsedTaskId === null) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            const [parseError, parsedData] = await catchError(
+                Promise.resolve().then(
+                    () => JSON.parse(options.data) as unknown,
+                ),
+            );
+            if (parseError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: "Invalid JSON in --data",
+                    Instructions: extractErrorMessageSync(parseError),
+                });
+                processContext.exit(1);
+                return;
+            }
+            if (
+                typeof parsedData !== "object" ||
+                parsedData === null ||
+                Array.isArray(parsedData)
+            ) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: "--data must be a JSON object",
+                    Instructions:
+                        'Provide a JSON object, e.g. \'{"field":"value"}\'.',
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            const [saveError] = await catchError(
+                sdk.tasks.saveData(
+                    parsedTaskId,
+                    parsedData as Record<string, unknown>,
+                    { folderId },
+                ),
+            );
+            if (saveError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: `Error saving data for task '${taskId}'`,
+                    Instructions: await extractErrorMessage(saveError),
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskDataSaved",
+                Data: { taskId: parsedTaskId },
+            });
+        },
+    );
+};

package/src/commands/labels.ts

@@ -0,0 +1,93 @@
+import {
+    catchError,
+    extractErrorMessage,
+    extractErrorMessageSync,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { Tag } from "@uipath/uipath-typescript";
+import type { Command } from "commander";
+
+import { connectTasksClient } from "./_shared/connect";
+import {
+    addFolderScopeOptions,
+    type FolderScopeOptions,
+    resolveFolderId,
+} from "./_shared/folder-picker";
+import { parseIntArg } from "./_shared/parse";
+
+interface LabelsOptions extends FolderScopeOptions {
+    labels: string;
+}
+
+export const registerLabelsCommand = (program: Command) => {
+    addFolderScopeOptions(
+        program
+            .command("labels")
+            .description("Set or clear the labels on a task")
+            .argument("<task-id>", "Task ID")
+            .requiredOption(
+                "--labels <json>",
+                'Labels as a JSON array, e.g. \'[{"name":"region","displayName":"Region","displayValue":"EMEA"}]\' (use \'[]\' to clear)',
+            ),
+    ).trackedAction(
+        processContext,
+        async (taskId: string, options: LabelsOptions) => {
+            const sdk = await connectTasksClient();
+            if (!sdk) return;
+
+            const parsedTaskId = parseIntArg(taskId, "<task-id>");
+            if (parsedTaskId === null) return;
+
+            const folderId = await resolveFolderId(options);
+            if (folderId === null) return;
+
+            const [parseError, parsedLabels] = await catchError(
+                Promise.resolve().then(
+                    () => JSON.parse(options.labels) as unknown,
+                ),
+            );
+            if (parseError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: "Invalid JSON in --labels",
+                    Instructions: extractErrorMessageSync(parseError),
+                });
+                processContext.exit(1);
+                return;
+            }
+            if (!Array.isArray(parsedLabels)) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: "--labels must be a JSON array",
+                    Instructions:
+                        'Provide a JSON array of labels, e.g. \'[{"name":"region","displayName":"Region","displayValue":"EMEA"}]\'.',
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            const [saveError] = await catchError(
+                sdk.tasks.saveTags(parsedTaskId, parsedLabels as Tag[], {
+                    folderId,
+                }),
+            );
+            if (saveError) {
+                OutputFormatter.error({
+                    Result: RESULTS.Failure,
+                    Message: `Error saving labels on task '${taskId}'`,
+                    Instructions: await extractErrorMessage(saveError),
+                });
+                processContext.exit(1);
+                return;
+            }
+
+            OutputFormatter.success({
+                Result: RESULTS.Success,
+                Code: "TaskLabelsSaved",
+                Data: { taskId: parsedTaskId, labels: parsedLabels },
+            });
+        },
+    );
+};