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

package/src/commands/tasks.ts

@@ -1,631 +0,0 @@
-import {
-    type CommandExample,
-    catchError,
-    createHiddenDeprecatedTenantOption,
-    extractErrorMessage,
-    extractErrorMessageSync,
-    OutputFormatter,
-    processContext,
-    RESULTS,
-} from "@uipath/common";
-import type { TaskCompletionOptions } from "@uipath/uipath-typescript";
-import { type Command, Option } from "commander";
-
-import { connectTasksClient } from "./_shared/connect";
-import { DEFAULT_PAGE_SIZE } from "./_shared/constants";
-import {
-    addFolderScopeOptions,
-    type FolderScopeOptions,
-    resolveFolderId,
-    resolveFolderScope,
-} from "./_shared/folder-picker";
-import { parseIntArg } from "./_shared/parse";
-
-const VALID_TASK_TYPES = [
-    "FormTask",
-    "ExternalTask",
-    "AppTask",
-    "DocumentValidationTask",
-    "DocumentClassificationTask",
-    "DataLabelingTask",
-    "QuickFormTask",
-] as const;
-type ValidTaskType = (typeof VALID_TASK_TYPES)[number];
-
-interface ListOptions extends FolderScopeOptions {
-    asAdmin?: boolean;
-    limit?: string;
-}
-
-interface GetOptions extends FolderScopeOptions {
-    taskType?: string;
-}
-
-interface AssignOptions {
-    tenant?: string;
-    userId?: string;
-    user?: string;
-}
-
-interface CompleteOptions extends FolderScopeOptions {
-    type: string;
-    data?: string;
-    action?: string;
-}
-
-interface UsersOptions extends FolderScopeOptions {
-    limit?: string;
-}
-
-const TASKS_USERS_EXAMPLES: CommandExample[] = [
-    {
-        Description: "List users with task permissions in a folder",
-        Command: "uip tasks users 42",
-        Output: {
-            Code: "TaskUserList",
-            Data: [
-                {
-                    id: 1,
-                    name: "Alice",
-                    surname: "Smith",
-                    userName: "alice",
-                    emailAddress: "alice@company.com",
-                    displayName: "Alice Smith",
-                },
-                {
-                    id: 2,
-                    name: "Bob",
-                    surname: "Jones",
-                    userName: "bob",
-                    emailAddress: "bob@company.com",
-                    displayName: "Bob Jones",
-                },
-            ],
-        },
-    },
-    {
-        Description: "Limit the number of users returned",
-        Command: "uip tasks users 42 --limit 10",
-        Output: {
-            Code: "TaskUserList",
-            Data: [
-                {
-                    id: 1,
-                    name: "Alice",
-                    surname: "Smith",
-                    userName: "alice",
-                    emailAddress: "alice@company.com",
-                    displayName: "Alice Smith",
-                },
-            ],
-        },
-    },
-    {
-        Description:
-            "List users by folder path instead of the numeric folder ID",
-        Command: 'uip tasks users --folder-path "Shared/Finance"',
-        Output: {
-            Code: "TaskUserList",
-            Data: [
-                {
-                    id: 1,
-                    name: "Alice",
-                    surname: "Smith",
-                    userName: "alice",
-                    emailAddress: "alice@company.com",
-                    displayName: "Alice Smith",
-                },
-            ],
-        },
-    },
-];
-
-export const registerTasksCommand = (program: Command) => {
-    addFolderScopeOptions(
-        program
-            .command("list")
-            .description("List tasks across folders")
-            .addOption(
-                createHiddenDeprecatedTenantOption(
-                    "-t, --tenant <tenant-name>",
-                ),
-            ),
-        "Filter by folder ID",
-    )
-        .option("--as-admin", "List tasks as admin")
-        .option(
-            "-l, --limit <number>",
-            "Maximum number of items to return (fetches all if omitted)",
-        )
-        .trackedAction(processContext, async (options: ListOptions) => {
-            const sdk = await connectTasksClient(options.tenant);
-            if (!sdk) return;
-
-            let limit: number | undefined;
-            if (options.limit) {
-                const parsed = parseIntArg(options.limit, "--limit");
-                if (parsed === null) return;
-                limit = parsed;
-            }
-
-            const folderId = await resolveFolderScope(options);
-            if (folderId === null) return;
-
-            const allItems: unknown[] = [];
-            let cursor: { value: string } | undefined;
-
-            do {
-                const getOptions: Record<string, unknown> = {
-                    pageSize: DEFAULT_PAGE_SIZE,
-                };
-                if (folderId !== undefined) {
-                    getOptions.folderId = folderId;
-                }
-                if (options.asAdmin) {
-                    getOptions.asTaskAdmin = true;
-                }
-                if (cursor) {
-                    getOptions.cursor = cursor;
-                }
-
-                const [listError, result] = await catchError(
-                    sdk.tasks.getAll(getOptions),
-                );
-
-                if (listError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error listing tasks",
-                        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>;
-                const items = (page.items ?? []) as unknown[];
-                allItems.push(...items);
-
-                cursor = page.hasNextPage
-                    ? (page.nextCursor as { value: string })
-                    : undefined;
-
-                if (limit && allItems.length >= limit) {
-                    break;
-                }
-            } while (cursor);
-
-            const data = limit ? allItems.slice(0, limit) : allItems;
-
-            OutputFormatter.success({
-                Result: RESULTS.Success,
-                Code: "TaskList",
-                Data: data,
-            });
-        });
-
-    addFolderScopeOptions(
-        program
-            .command("get")
-            .description(
-                "Get details of a task by ID. Use 'tasks list' to find task IDs.",
-            )
-            .argument("<id>", "Task ID")
-            .addOption(
-                createHiddenDeprecatedTenantOption(
-                    "-t, --tenant <tenant-name>",
-                ),
-            )
-            .option(
-                "--task-type <type>",
-                "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask, QuickFormTask)",
-            ),
-        "Folder ID (a folder is required when task-type is specified)",
-    ).trackedAction(processContext, async (id: string, options: GetOptions) => {
-        const sdk = await connectTasksClient(options.tenant);
-        if (!sdk) return;
-
-        const parsedId = parseIntArg(id, "<id>");
-        if (parsedId === null) return;
-
-        const hasFolderScope =
-            options.folderId !== undefined ||
-            options.folderPath !== undefined ||
-            options.folderKey !== undefined;
-        if (options.taskType && !hasFolderScope) {
-            OutputFormatter.error({
-                Result: RESULTS.Failure,
-                Message: "A folder is required when --task-type is specified",
-                Instructions:
-                    "Pass --folder-id <id>, --folder-path <path>, or --folder-key <key>.",
-            });
-            processContext.exit(1);
-            return;
-        }
-
-        const getOptions: Record<string, unknown> = {};
-        if (options.taskType) {
-            getOptions.taskType = options.taskType;
-        }
-        const folderId = await resolveFolderScope(options);
-        if (folderId === null) return;
-
-        const [getError, task] = await catchError(
-            sdk.tasks.getById(parsedId, getOptions, folderId),
-        );
-
-        if (getError) {
-            OutputFormatter.error({
-                Result: RESULTS.Failure,
-                Message: `Error getting task '${id}'`,
-                Instructions: await extractErrorMessage(getError),
-            });
-            processContext.exit(1);
-            return;
-        }
-
-        OutputFormatter.success({
-            Result: RESULTS.Success,
-            Code: "TaskDetails",
-            Data: task,
-        });
-    });
-
-    program
-        .command("assign")
-        .description("Assign a task to a user")
-        .argument("<task-id>", "Task ID")
-        .addOption(
-            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
-        )
-        .option("--user-id <id>", "User ID")
-        .option(
-            "--user <email>",
-            "User name or email (alternative to --user-id)",
-        )
-        .trackedAction(
-            processContext,
-            async (taskId: string, options: AssignOptions) => {
-                await assignOrReassign(taskId, options, "assign");
-            },
-        );
-
-    program
-        .command("reassign")
-        .description("Reassign a task to a different user")
-        .argument("<task-id>", "Task ID")
-        .addOption(
-            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
-        )
-        .option("--user-id <id>", "User ID")
-        .option(
-            "--user <email>",
-            "User name or email (alternative to --user-id)",
-        )
-        .trackedAction(
-            processContext,
-            async (taskId: string, options: AssignOptions) => {
-                await assignOrReassign(taskId, options, "reassign");
-            },
-        );
-
-    program
-        .command("unassign")
-        .description("Remove the assignee from a task")
-        .argument("<task-id>", "Task ID")
-        .addOption(
-            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
-        )
-        .trackedAction(
-            processContext,
-            async (taskId: string, options: { tenant?: string }) => {
-                const sdk = await connectTasksClient(options.tenant);
-                if (!sdk) return;
-
-                const parsedId = parseIntArg(taskId, "<task-id>");
-                if (parsedId === null) return;
-
-                const [unassignError, result] = await catchError(
-                    sdk.tasks.unassign(parsedId),
-                );
-
-                if (unassignError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error unassigning task '${taskId}'`,
-                        Instructions: await extractErrorMessage(unassignError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                OutputFormatter.success({
-                    Result: RESULTS.Success,
-                    Code: "TaskUnassigned",
-                    Data: result,
-                });
-            },
-        );
-
-    addFolderScopeOptions(
-        program
-            .command("complete")
-            .description("Complete a task with an action and optional data")
-            .argument("<task-id>", "Task ID")
-            .requiredOption(
-                "--type <type>",
-                "Task type (FormTask, ExternalTask, AppTask, DocumentValidationTask, DocumentClassificationTask, DataLabelingTask, QuickFormTask)",
-            )
-            .addOption(
-                createHiddenDeprecatedTenantOption(
-                    "-t, --tenant <tenant-name>",
-                ),
-            ),
-    )
-        .option("--data <json>", "Task data as JSON string")
-        .option(
-            "--action <action>",
-            "Action name (required for FormTask and AppTask)",
-        )
-        .trackedAction(
-            processContext,
-            async (taskId: string, options: CompleteOptions) => {
-                const sdk = await connectTasksClient(options.tenant);
-                if (!sdk) return;
-
-                const parsedTaskId = parseIntArg(taskId, "<task-id>");
-                if (parsedTaskId === null) return;
-
-                if (!VALID_TASK_TYPES.includes(options.type as ValidTaskType)) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Invalid task type '${options.type}'`,
-                        Instructions: `Valid types: ${VALID_TASK_TYPES.join(", ")}`,
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                const folderId = await resolveFolderId(options);
-                if (folderId === null) return;
-
-                const completionOptions: Record<string, unknown> = {
-                    taskId: parsedTaskId,
-                    type: options.type,
-                };
-
-                if (options.action) {
-                    completionOptions.action = options.action;
-                }
-
-                if (options.data) {
-                    const [parseError, parsed] = await catchError(
-                        Promise.resolve().then(
-                            () => JSON.parse(options.data as string) as unknown,
-                        ),
-                    );
-                    if (parseError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Invalid JSON in --data",
-                            Instructions: extractErrorMessageSync(parseError),
-                        });
-                        processContext.exit(1);
-                        return;
-                    }
-                    completionOptions.data = parsed;
-                }
-
-                // CLI receives type as a raw string; SDK expects a TaskType enum discriminated union.
-                const [completeError, result] = await catchError(
-                    sdk.tasks.complete(
-                        completionOptions as unknown as TaskCompletionOptions,
-                        folderId,
-                    ),
-                );
-
-                if (completeError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error completing task '${taskId}'`,
-                        Instructions: await extractErrorMessage(completeError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                OutputFormatter.success({
-                    Result: RESULTS.Success,
-                    Code: "TaskCompleted",
-                    Data: result,
-                });
-            },
-        );
-
-    program
-        .command("users")
-        .description(
-            "List users with task permissions in a folder. Use the user ID with 'tasks assign'.",
-        )
-        .argument(
-            "[folder-id]",
-            "Folder ID (alternatively pass --folder-path or --folder-key)",
-        )
-        .addOption(
-            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
-        )
-        .addOption(
-            new Option(
-                "--folder-path <path>",
-                "Folder path (alternative to the folder-id argument)",
-            ).conflicts("folderKey"),
-        )
-        .addOption(
-            new Option(
-                "--folder-key <key>",
-                "Folder key (alternative to the folder-id argument)",
-            ),
-        )
-        .option(
-            "-l, --limit <number>",
-            "Maximum number of items to return (fetches all if omitted)",
-        )
-        .examples(TASKS_USERS_EXAMPLES)
-        .trackedAction(
-            processContext,
-            async (folderId: string | undefined, options: UsersOptions) => {
-                const sdk = await connectTasksClient(options.tenant);
-                if (!sdk) return;
-
-                if (
-                    folderId !== undefined &&
-                    (options.folderPath !== undefined ||
-                        options.folderKey !== undefined)
-                ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message:
-                            "The folder-id argument cannot be used with --folder-path or --folder-key",
-                        Instructions:
-                            "Pass the folder as a numeric argument, or as --folder-path/--folder-key, not both.",
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                const parsedFolderId =
-                    folderId !== undefined
-                        ? parseIntArg(folderId, "<folder-id>")
-                        : await resolveFolderId(
-                              options,
-                              "Pass the folder-id argument, --folder-path <path>, or --folder-key <key> (run 'uip or folders list' to find one).",
-                          );
-                if (parsedFolderId === 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> = {
-                        pageSize: DEFAULT_PAGE_SIZE,
-                    };
-                    if (cursor) {
-                        getOptions.cursor = cursor;
-                    }
-
-                    const [usersError, result] = await catchError(
-                        sdk.tasks.getUsers(parsedFolderId, getOptions),
-                    );
-
-                    if (usersError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error listing task users",
-                            Instructions: await extractErrorMessage(usersError),
-                        });
-                        processContext.exit(1);
-                        return;
-                    }
-
-                    if (Array.isArray(result)) {
-                        allItems.push(...result);
-                        break;
-                    }
-
-                    const page = result as unknown as Record<string, unknown>;
-                    const items = (page.items ?? []) as unknown[];
-                    allItems.push(...items);
-
-                    cursor = page.hasNextPage
-                        ? (page.nextCursor as { value: string })
-                        : undefined;
-
-                    if (limit && allItems.length >= limit) {
-                        break;
-                    }
-                } while (cursor);
-
-                const data = limit ? allItems.slice(0, limit) : allItems;
-
-                OutputFormatter.success({
-                    Result: RESULTS.Success,
-                    Code: "TaskUserList",
-                    Data: data,
-                });
-            },
-        );
-};
-
-async function assignOrReassign(
-    taskId: string,
-    options: AssignOptions,
-    action: "assign" | "reassign",
-): Promise<void> {
-    if (!options.userId && !options.user) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: "Missing assignee",
-            Instructions:
-                action === "assign"
-                    ? "Provide either --user-id or --user to specify the assignee."
-                    : "Provide either --user-id or --user to specify the new assignee.",
-        });
-        processContext.exit(1);
-        return;
-    }
-
-    const sdk = await connectTasksClient(options.tenant);
-    if (!sdk) return;
-
-    const parsedTaskId = parseIntArg(taskId, "<task-id>");
-    if (parsedTaskId === null) return;
-
-    const assignment: Record<string, unknown> = {
-        taskId: parsedTaskId,
-    };
-    if (options.userId) {
-        const parsedUserId = parseIntArg(options.userId, "--user-id");
-        if (parsedUserId === null) return;
-        assignment.userId = parsedUserId;
-    } else {
-        assignment.userNameOrEmail = options.user;
-    }
-
-    type TaskAssignment =
-        | { taskId: number; userId: number }
-        | { taskId: number; userNameOrEmail: string };
-
-    const [error, result] = await catchError(
-        action === "assign"
-            ? sdk.tasks.assign(assignment as TaskAssignment)
-            : sdk.tasks.reassign(assignment as TaskAssignment),
-    );
-
-    if (error) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Error ${action === "assign" ? "assigning" : "reassigning"} task '${taskId}'`,
-            Instructions: await extractErrorMessage(error),
-        });
-        processContext.exit(1);
-        return;
-    }
-
-    OutputFormatter.success({
-        Result: RESULTS.Success,
-        Code: action === "assign" ? "TaskAssigned" : "TaskReassigned",
-        Data: result,
-    });
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env bun
-import { Command } from "commander";
-import { metadata, registerCommands } from "./tool.js";
-
-const program = new Command();
-program
-    .name(metadata.name)
-    .description(metadata.description)
-    .version(metadata.version);
-
-await registerCommands(program);
-await program.parseAsync(process.argv);

package/src/tool.ts

@@ -1,24 +0,0 @@
-import type { Command } from "commander";
-import pkg from "../package.json" with { type: "json" };
-import { registerCatalogsCommand } from "./commands/catalogs";
-import { registerCommentsCommand } from "./commands/comments";
-import { registerDataCommand } from "./commands/data";
-import { registerLabelsCommand } from "./commands/labels";
-import { registerMetadataCommand } from "./commands/metadata";
-import { registerTasksCommand } from "./commands/tasks";
-
-export const metadata = {
-    name: "tasks-tool",
-    version: pkg.version,
-    description: "Manage Action Center tasks.",
-    commandPrefix: "tasks",
-};
-
-export const registerCommands = async (program: Command): Promise<void> => {
-    registerTasksCommand(program);
-    registerCatalogsCommand(program);
-    registerCommentsCommand(program);
-    registerLabelsCommand(program);
-    registerMetadataCommand(program);
-    registerDataCommand(program);
-};

package/src/utils/sdk-client.ts

@@ -1,30 +0,0 @@
-import { getLoginStatusAsync } from "@uipath/auth";
-import { UiPath } from "@uipath/uipath-typescript";
-import { TaskCatalogs } from "@uipath/uipath-typescript/tasks";
-
-export const createTasksClient = async (
-    tenantOverride?: string,
-): Promise<UiPath> => {
-    const status = await getLoginStatusAsync({
-        ensureTokenValidityMinutes: 10,
-    });
-
-    if (
-        status.loginStatus !== "Logged in" ||
-        !status.accessToken ||
-        !status.baseUrl
-    ) {
-        throw new Error(status.hint ?? "Not logged in. Run 'uip login' first.");
-    }
-
-    return new UiPath({
-        secret: status.accessToken,
-        baseUrl: status.baseUrl,
-        orgName: status.organizationName,
-        tenantName: tenantOverride ?? status.tenantName,
-    });
-};
-
-// Task catalogs live on their own service in the SDK, not on `sdk.tasks`.
-export const createTaskCatalogsClient = (sdk: UiPath): TaskCatalogs =>
-    new TaskCatalogs(sdk);