@uipath/tasks-tool 1.202.0-preview.140 → 1.202.0-preview.142

package/src/commands/catalogs.ts

@@ -1,281 +0,0 @@
-import {
-    catchError,
-    classifiedFailure,
-    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(
-                        await classifiedFailure(
-                            "Error listing task catalogs",
-                            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(
-                    await classifiedFailure(
-                        `Error getting task catalog '${id}'`,
-                        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(
-                        await classifiedFailure(
-                            `Error creating task catalog '${options.name}'`,
-                            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(
-                        await classifiedFailure(
-                            `Error updating task catalog '${id}'`,
-                            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

@@ -1,160 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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 },
-            });
-        },
-    );
-};