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

package/dist/tool.js

@@ -1,7 +1,8 @@
 import {
   metadata,
   registerCommands
-} from "./tool-vw6gha5d.js";
+} from "./tool-ww671age.js";
+import"./tool-rsk1xt86.js";
 import"./tool-9qecd4wb.js";
 import"./tool-7eva0peq.js";
 import"./tool-5arsyj36.js";
@@ -12,4 +13,4 @@ export {
   metadata
 };
 
-//# debugId=41CB38F55D92291A64756E2164756E21
+//# debugId=106E34AF1A233DCE64756E2164756E21

package/package.json

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

package/src/commands/_shared/catalog-options.spec.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: { success: vi.fn(), error: vi.fn() },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import {
+    buildCatalogCreateOptions,
+    buildCatalogUpdateOptions,
+} from "./catalog-options";
+
+describe("buildCatalogCreateOptions", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("builds folderId only", () => {
+        expect(
+            buildCatalogCreateOptions({ folderId: "42", name: "x" }, 42),
+        ).toEqual({ folderId: 42 });
+    });
+
+    it("includes description, encryption, and retention", () => {
+        const result = buildCatalogCreateOptions(
+            {
+                folderId: "42",
+                name: "x",
+                description: "desc",
+                encrypted: true,
+                retentionAction: "Archive",
+                retentionPeriod: "30",
+                retentionBucketId: "7",
+            },
+            42,
+        );
+        expect(result).toEqual({
+            folderId: 42,
+            description: "desc",
+            encrypted: true,
+            retentionAction: "Archive",
+            retentionPeriod: 30,
+            retentionBucketId: 7,
+        });
+    });
+
+    it("rejects an invalid retention action", () => {
+        const result = buildCatalogCreateOptions(
+            { folderId: "42", name: "x", retentionAction: "Purge" },
+            42,
+        );
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "Invalid --retention-action 'Purge'",
+            }),
+        );
+    });
+
+    it.each([
+        ["retentionPeriod", "--retention-period"],
+        ["retentionBucketId", "--retention-bucket-id"],
+    ])("rejects an invalid %s", (field, flag) => {
+        const result = buildCatalogCreateOptions(
+            { folderId: "42", name: "x", [field]: "abc" },
+            42,
+        );
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({ Message: `Invalid ${flag}: abc` }),
+        );
+    });
+});
+
+describe("buildCatalogUpdateOptions", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("includes name when provided", () => {
+        expect(
+            buildCatalogUpdateOptions({ folderId: "42", name: "renamed" }, 42),
+        ).toEqual({ folderId: 42, name: "renamed" });
+    });
+
+    it("omits name when not provided and never sets encrypted", () => {
+        const result = buildCatalogUpdateOptions(
+            { folderId: "42", description: "d" },
+            42,
+        );
+        expect(result).toEqual({ folderId: 42, description: "d" });
+        expect(result).not.toHaveProperty("name");
+        expect(result).not.toHaveProperty("encrypted");
+    });
+
+    it("rejects an invalid retention action", () => {
+        const result = buildCatalogUpdateOptions(
+            { folderId: "42", retentionAction: "Nope" },
+            42,
+        );
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "Invalid --retention-action 'Nope'",
+            }),
+        );
+    });
+});

package/src/commands/_shared/catalog-options.ts

@@ -0,0 +1,122 @@
+import { OutputFormatter, processContext, RESULTS } from "@uipath/common";
+import type {
+    TaskCatalogCreateOptions,
+    TaskCatalogUpdateOptions,
+} from "@uipath/uipath-typescript";
+import { TaskCatalogRetentionAction } from "@uipath/uipath-typescript";
+
+import type { FolderScopeOptions } from "./folder-picker";
+import { parsePositiveInt, reportInvalidInt } from "./parse";
+
+// None is a read-only state, not a settable action, so the CLI only offers Delete and Archive.
+const RETENTION_ACTIONS: TaskCatalogRetentionAction[] = [
+    TaskCatalogRetentionAction.Delete,
+    TaskCatalogRetentionAction.Archive,
+];
+
+export interface CatalogListOptions extends FolderScopeOptions {
+    limit?: string;
+}
+
+export type CatalogGetOptions = FolderScopeOptions;
+
+export interface CatalogCreateOptions extends FolderScopeOptions {
+    name: string;
+    description?: string;
+    encrypted?: boolean;
+    retentionAction?: string;
+    retentionPeriod?: string;
+    retentionBucketId?: string;
+}
+
+export interface CatalogUpdateOptions extends FolderScopeOptions {
+    name?: string;
+    description?: string;
+    retentionAction?: string;
+    retentionPeriod?: string;
+    retentionBucketId?: string;
+}
+
+// Common retention/description fields shared by create and update. Returns
+// false after emitting an error + exit when a value is invalid.
+function applyCommonFields(
+    target: {
+        description?: string;
+        retentionAction?: TaskCatalogRetentionAction;
+        retentionPeriod?: number;
+        retentionBucketId?: number;
+    },
+    options: {
+        description?: string;
+        retentionAction?: string;
+        retentionPeriod?: string;
+        retentionBucketId?: string;
+    },
+): boolean {
+    if (options.description !== undefined) {
+        target.description = options.description;
+    }
+    if (options.retentionAction !== undefined) {
+        if (
+            !RETENTION_ACTIONS.includes(
+                options.retentionAction as TaskCatalogRetentionAction,
+            )
+        ) {
+            OutputFormatter.error({
+                Result: RESULTS.Failure,
+                Message: `Invalid --retention-action '${options.retentionAction}'`,
+                Instructions: `Valid values: ${RETENTION_ACTIONS.join(", ")}`,
+            });
+            processContext.exit(1);
+            return false;
+        }
+        target.retentionAction =
+            options.retentionAction as TaskCatalogRetentionAction;
+    }
+    if (options.retentionPeriod !== undefined) {
+        const parsed = parsePositiveInt(
+            options.retentionPeriod,
+            "--retention-period",
+        );
+        if (!parsed.valid) {
+            reportInvalidInt(parsed);
+            return false;
+        }
+        target.retentionPeriod = parsed.value;
+    }
+    if (options.retentionBucketId !== undefined) {
+        const parsed = parsePositiveInt(
+            options.retentionBucketId,
+            "--retention-bucket-id",
+        );
+        if (!parsed.valid) {
+            reportInvalidInt(parsed);
+            return false;
+        }
+        target.retentionBucketId = parsed.value;
+    }
+    return true;
+}
+
+export function buildCatalogCreateOptions(
+    options: CatalogCreateOptions,
+    folderId: number,
+): TaskCatalogCreateOptions | null {
+    const result: TaskCatalogCreateOptions = { folderId };
+    if (options.encrypted) {
+        result.encrypted = true;
+    }
+    return applyCommonFields(result, options) ? result : null;
+}
+
+export function buildCatalogUpdateOptions(
+    options: CatalogUpdateOptions,
+    folderId: number,
+): TaskCatalogUpdateOptions | null {
+    // `encrypted` is immutable on update, so it is intentionally not set here.
+    const result: TaskCatalogUpdateOptions = { folderId };
+    if (options.name !== undefined) {
+        result.name = options.name;
+    }
+    return applyCommonFields(result, options) ? result : null;
+}

package/src/commands/_shared/connect.spec.ts

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../utils/sdk-client", () => ({
+    createTasksClient: vi.fn(),
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: { success: vi.fn(), error: vi.fn() },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import { createTasksClient } from "../../utils/sdk-client";
+import { connectTasksClient } from "./connect";
+
+describe("connectTasksClient", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("returns the client on success", async () => {
+        const sdk = { tasks: {} };
+        vi.mocked(createTasksClient).mockResolvedValue(sdk as never);
+
+        const result = await connectTasksClient("MyTenant");
+
+        expect(result).toBe(sdk);
+        expect(createTasksClient).toHaveBeenCalledWith("MyTenant");
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+    });
+
+    it("reports, exits, and returns null on failure", async () => {
+        vi.mocked(createTasksClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+
+        const result = await connectTasksClient();
+
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});

package/src/commands/_shared/connect.ts

@@ -0,0 +1,31 @@
+import {
+    catchError,
+    extractErrorMessage,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { UiPath } from "@uipath/uipath-typescript";
+
+import { createTasksClient } from "../../utils/sdk-client";
+
+/**
+ * Connects to Action Center for the given tenant. On failure, emits the
+ * standard error, exits with code 1, and returns null so the caller can
+ * `return` early. Keeps the connect boilerplate in one place.
+ */
+export async function connectTasksClient(
+    tenant?: string,
+): Promise<UiPath | null> {
+    const [clientError, sdk] = await catchError(createTasksClient(tenant));
+    if (clientError) {
+        OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "Error connecting to Action Center",
+            Instructions: await extractErrorMessage(clientError),
+        });
+        processContext.exit(1);
+        return null;
+    }
+    return sdk;
+}

package/src/commands/_shared/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_PAGE_SIZE = 100;

package/src/commands/_shared/folder-picker-interactive.spec.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@inquirer/prompts", () => ({ select: vi.fn() }));
+
+vi.mock("@uipath/orchestrator-sdk", () => ({
+    createApiClient: vi.fn(),
+    FoldersApi: class {},
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: { success: vi.fn(), error: vi.fn() },
+    };
+});
+
+import { select } from "@inquirer/prompts";
+import { OutputFormatter } from "@uipath/common";
+import { createApiClient } from "@uipath/orchestrator-sdk";
+import { pickFolderInteractively } from "./folder-picker-interactive";
+
+function mockFolders(pageItems: unknown[]) {
+    vi.mocked(createApiClient).mockResolvedValue({
+        foldersGetAllForCurrentUser: vi.fn().mockResolvedValue({ pageItems }),
+    } as never);
+}
+
+describe("pickFolderInteractively", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("lists folders and returns the selected id", async () => {
+        mockFolders([
+            { id: 7, displayName: "Finance" },
+            { id: 9, displayName: "HR" },
+        ]);
+        vi.mocked(select).mockResolvedValue(7 as never);
+
+        expect(await pickFolderInteractively()).toBe(7);
+        expect(select).toHaveBeenCalled();
+    });
+
+    it("passes the tenant through to the folder client", async () => {
+        mockFolders([{ id: 7, displayName: "Finance" }]);
+        vi.mocked(select).mockResolvedValue(7 as never);
+
+        expect(await pickFolderInteractively("my-tenant")).toBe(7);
+        expect(createApiClient).toHaveBeenCalledWith(expect.anything(), {
+            tenant: "my-tenant",
+        });
+    });
+
+    it("reports a connection error", async () => {
+        vi.mocked(createApiClient).mockRejectedValue(new Error("boom"));
+
+        expect(await pickFolderInteractively()).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "Error connecting to Action Center",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("reports a listing error", async () => {
+        vi.mocked(createApiClient).mockResolvedValue({
+            foldersGetAllForCurrentUser: vi
+                .fn()
+                .mockRejectedValue(new Error("nope")),
+        } as never);
+
+        expect(await pickFolderInteractively()).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({ Message: "Error listing folders" }),
+        );
+    });
+
+    it("fails when no selectable folders are returned", async () => {
+        mockFolders([{ displayName: "no id here" }]);
+
+        expect(await pickFolderInteractively()).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "No folders available to select",
+            }),
+        );
+        expect(select).not.toHaveBeenCalled();
+    });
+});

package/src/commands/_shared/folder-picker-interactive.ts

@@ -0,0 +1,76 @@
+import { select } from "@inquirer/prompts";
+import {
+    catchError,
+    extractErrorMessage,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import {
+    type CurrentUserFolderDto,
+    createApiClient,
+    FoldersApi,
+} from "@uipath/orchestrator-sdk";
+
+const FOLDER_PAGE_SIZE = 200;
+
+/**
+ * Interactive folder picker. Pulls @inquirer/prompts, which is Node-only
+ * (TTY prompts), so it is excluded from the browser bundle
+ * (browser.json -> excludedImports) and only imported on a TTY.
+ * (@uipath/orchestrator-sdk itself is browser-safe — it ships a browser
+ * export and reaches the browser bundle through folder-resolver.)
+ *
+ * Returns null when listing/selection fails (after emitting an error + exit).
+ */
+export async function pickFolderInteractively(
+    tenant?: string,
+): Promise<number | null> {
+    const [clientError, api] = await catchError(
+        createApiClient(FoldersApi, { tenant }),
+    );
+    if (clientError) {
+        OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "Error connecting to Action Center",
+            Instructions: await extractErrorMessage(clientError),
+        });
+        processContext.exit(1);
+        return null;
+    }
+
+    const [listError, result] = await catchError(
+        api.foldersGetAllForCurrentUser({ take: FOLDER_PAGE_SIZE }),
+    );
+    if (listError) {
+        OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "Error listing folders",
+            Instructions: await extractErrorMessage(listError),
+        });
+        processContext.exit(1);
+        return null;
+    }
+
+    const folders = (result.pageItems ?? []).filter(
+        (f: CurrentUserFolderDto): f is CurrentUserFolderDto & { id: number } =>
+            typeof f.id === "number",
+    );
+    if (folders.length === 0) {
+        OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "No folders available to select",
+            Instructions: "Pass --folder-id <id> instead.",
+        });
+        processContext.exit(1);
+        return null;
+    }
+
+    return select<number>({
+        message: "Select a folder",
+        choices: folders.map((f) => ({
+            name: f.fullyQualifiedName || f.displayName || String(f.id),
+            value: f.id,
+        })),
+    });
+}

package/src/commands/_shared/folder-picker.spec.ts

@@ -0,0 +1,159 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("./folder-picker-interactive", () => ({
+    pickFolderInteractively: vi.fn(),
+}));
+
+vi.mock("./folder-resolver", () => ({
+    resolveFolderIdByKey: vi.fn(),
+    resolveFolderIdByPath: vi.fn(),
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: { success: vi.fn(), error: vi.fn() },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import { resolveFolderId, resolveFolderScope } from "./folder-picker";
+import { pickFolderInteractively } from "./folder-picker-interactive";
+import { resolveFolderIdByKey, resolveFolderIdByPath } from "./folder-resolver";
+
+const FOLDER_KEY = "12345678-1234-1234-1234-123456789abc";
+
+describe("resolveFolderScope", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("parses and returns the id when --folder-id is provided", async () => {
+        expect(await resolveFolderScope({ folderId: "42" })).toBe(42);
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+        expect(resolveFolderIdByKey).not.toHaveBeenCalled();
+        expect(resolveFolderIdByPath).not.toHaveBeenCalled();
+    });
+
+    it("reports an invalid --folder-id", async () => {
+        expect(await resolveFolderScope({ folderId: "abc" })).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({ Message: "Invalid --folder-id: abc" }),
+        );
+    });
+
+    it("resolves --folder-key through the folder resolver", async () => {
+        vi.mocked(resolveFolderIdByKey).mockResolvedValue(55);
+
+        expect(
+            await resolveFolderScope({ folderKey: FOLDER_KEY, tenant: "t1" }),
+        ).toBe(55);
+        expect(resolveFolderIdByKey).toHaveBeenCalledWith(FOLDER_KEY, "t1");
+        expect(resolveFolderIdByPath).not.toHaveBeenCalled();
+    });
+
+    it("resolves --folder-path through the folder resolver", async () => {
+        vi.mocked(resolveFolderIdByPath).mockResolvedValue(77);
+
+        expect(await resolveFolderScope({ folderPath: "Shared/Finance" })).toBe(
+            77,
+        );
+        expect(resolveFolderIdByPath).toHaveBeenCalledWith(
+            "Shared/Finance",
+            undefined,
+        );
+        expect(resolveFolderIdByKey).not.toHaveBeenCalled();
+    });
+
+    it("passes a resolver failure through as null", async () => {
+        vi.mocked(resolveFolderIdByKey).mockResolvedValue(null);
+
+        expect(await resolveFolderScope({ folderKey: FOLDER_KEY })).toBeNull();
+    });
+
+    it("returns undefined when no folder option is passed", async () => {
+        expect(await resolveFolderScope({})).toBeUndefined();
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+    });
+});
+
+describe("resolveFolderId", () => {
+    const originalTTY = process.stdout.isTTY;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    afterEach(() => {
+        process.stdout.isTTY = originalTTY;
+    });
+
+    it("parses and returns the id when --folder-id is provided", async () => {
+        expect(await resolveFolderId({ folderId: "42" })).toBe(42);
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+        expect(pickFolderInteractively).not.toHaveBeenCalled();
+    });
+
+    it("resolves --folder-path without falling back to the picker", async () => {
+        vi.mocked(resolveFolderIdByPath).mockResolvedValue(77);
+
+        expect(await resolveFolderId({ folderPath: "Shared" })).toBe(77);
+        expect(pickFolderInteractively).not.toHaveBeenCalled();
+    });
+
+    it("fails loud when omitted on a non-interactive terminal", async () => {
+        process.stdout.isTTY = false;
+
+        expect(await resolveFolderId({})).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "A folder is required",
+                Instructions: expect.stringContaining("--folder-id <id>"),
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+        expect(pickFolderInteractively).not.toHaveBeenCalled();
+    });
+
+    it("uses the caller's instructions when the command's folder options differ", async () => {
+        process.stdout.isTTY = false;
+
+        expect(
+            await resolveFolderId({}, "Pass the folder-id argument."),
+        ).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "A folder is required",
+                Instructions: "Pass the folder-id argument.",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("delegates to the interactive picker when omitted on a TTY", async () => {
+        process.stdout.isTTY = true;
+        vi.mocked(pickFolderInteractively).mockResolvedValue(7);
+
+        expect(await resolveFolderId({})).toBe(7);
+        expect(pickFolderInteractively).toHaveBeenCalledOnce();
+    });
+
+    it("passes the tenant to the interactive picker", async () => {
+        process.stdout.isTTY = true;
+        vi.mocked(pickFolderInteractively).mockResolvedValue(7);
+
+        expect(await resolveFolderId({ tenant: "my-tenant" })).toBe(7);
+        expect(pickFolderInteractively).toHaveBeenCalledWith("my-tenant");
+    });
+
+    it("does not fall back to the picker when resolution fails", async () => {
+        process.stdout.isTTY = true;
+        vi.mocked(resolveFolderIdByKey).mockResolvedValue(null);
+
+        expect(await resolveFolderId({ folderKey: FOLDER_KEY })).toBeNull();
+        expect(pickFolderInteractively).not.toHaveBeenCalled();
+    });
+});