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

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

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

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

@@ -1,113 +0,0 @@
-import { OutputFormatter, processContext, RESULTS } from "@uipath/common";
-import { type Command, Option } from "commander";
-
-import { parseIntArg } from "./parse";
-
-export interface FolderScopeOptions {
-    tenant?: string;
-    folderId?: string;
-    folderPath?: string;
-    folderKey?: string;
-}
-
-/**
- * Adds the folder scoping options (--folder-id, --folder-path, --folder-key)
- * to a command. The three are mutually exclusive; the pairs are declared via
- * Commander conflicts so misuse is rejected at parse time.
- */
-export function addFolderScopeOptions(
-    command: Command,
-    folderIdDescription = "Folder ID",
-): Command {
-    return command
-        .addOption(new Option("--folder-id <id>", folderIdDescription))
-        .addOption(
-            new Option(
-                "--folder-path <path>",
-                "Folder path (alternative to --folder-id)",
-            ).conflicts(["folderId", "folderKey"]),
-        )
-        .addOption(
-            new Option(
-                "--folder-key <key>",
-                "Folder key (alternative to --folder-id)",
-            ).conflicts("folderId"),
-        );
-}
-
-/**
- * Resolves the folder id from whichever folder option was passed:
- * - `--folder-id`: parse and use it.
- * - `--folder-path` / `--folder-key`: look the folder up in Orchestrator.
- * - none: return undefined.
- *
- * Returns null when resolution fails (after emitting an error + exit), so the
- * caller can `return` early.
- *
- * The path/key lookup lives in a separate module imported lazily, so its
- * FoldersApi chunk only loads when one of those flags is passed.
- */
-export async function resolveFolderScope(
-    options: FolderScopeOptions,
-): Promise<number | undefined | null> {
-    if (options.folderId !== undefined) {
-        return parseIntArg(options.folderId, "--folder-id");
-    }
-    if (options.folderKey !== undefined) {
-        const { resolveFolderIdByKey } = await import("./folder-resolver");
-        return resolveFolderIdByKey(options.folderKey, options.tenant);
-    }
-    if (options.folderPath !== undefined) {
-        const { resolveFolderIdByPath } = await import("./folder-resolver");
-        return resolveFolderIdByPath(options.folderPath, options.tenant);
-    }
-    return undefined;
-}
-
-/**
- * Default guidance for the fail-loud path. Commands whose folder options
- * differ (e.g. `tasks users`, where the folder id is a positional argument)
- * pass their own text so the guidance never names an option the command
- * doesn't have.
- */
-const DEFAULT_FOLDER_REQUIRED_INSTRUCTIONS =
-    "Pass --folder-id <id>, --folder-path <path>, or --folder-key <key> (run 'uip or folders list' to find one).";
-
-/**
- * Resolves the folder id for a command that needs one:
- * - a folder option passed: resolve it (see resolveFolderScope).
- * - none passed on an interactive terminal: show a folder picker.
- * - none passed on a non-interactive run (coding agents, CI): fail loud.
- *
- * Returns null when resolution fails (after emitting an error + exit), so the
- * caller can `return` early.
- *
- * The interactive picker lives in a separate module that pulls Node-only deps
- * (@inquirer/prompts). It is imported lazily so those deps stay out of the
- * browser bundle's static graph and only load on the TTY path, which never
- * runs in the browser.
- */
-export async function resolveFolderId(
-    options: FolderScopeOptions,
-    missingFolderInstructions = DEFAULT_FOLDER_REQUIRED_INSTRUCTIONS,
-): Promise<number | null> {
-    const resolved = await resolveFolderScope(options);
-    if (resolved !== undefined) {
-        return resolved;
-    }
-
-    if (!process.stdout.isTTY) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: "A folder is required",
-            Instructions: missingFolderInstructions,
-        });
-        processContext.exit(1);
-        return null;
-    }
-
-    const { pickFolderInteractively } = await import(
-        "./folder-picker-interactive"
-    );
-    return pickFolderInteractively(options.tenant);
-}

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

@@ -1,152 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@uipath/orchestrator-sdk", () => ({
-    resolveFolder: 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 { resolveFolder } from "@uipath/orchestrator-sdk";
-import { resolveFolderIdByKey, resolveFolderIdByPath } from "./folder-resolver";
-
-const FOLDER_KEY = "12345678-1234-1234-1234-123456789abc";
-
-const RESOLVED = {
-    id: 42,
-    key: FOLDER_KEY,
-    path: "Shared/Finance",
-    displayName: "Finance",
-};
-
-describe("resolveFolderIdByKey", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        process.exitCode = undefined;
-    });
-
-    it("rejects a value that is not a UUID without resolving", async () => {
-        expect(await resolveFolderIdByKey("not-a-guid")).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: "Invalid --folder-key: not-a-guid",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-        expect(resolveFolder).not.toHaveBeenCalled();
-    });
-
-    it("resolves the folder id through the SDK's shared resolveFolder", async () => {
-        vi.mocked(resolveFolder).mockResolvedValue(RESOLVED);
-
-        expect(await resolveFolderIdByKey(FOLDER_KEY)).toBe(42);
-        expect(resolveFolder).toHaveBeenCalledWith(
-            { folderKey: FOLDER_KEY },
-            { tenant: undefined },
-        );
-        expect(OutputFormatter.error).not.toHaveBeenCalled();
-    });
-
-    it("passes the tenant through", async () => {
-        vi.mocked(resolveFolder).mockResolvedValue(RESOLVED);
-
-        await resolveFolderIdByKey(FOLDER_KEY, "my-tenant");
-        expect(resolveFolder).toHaveBeenCalledWith(
-            { folderKey: FOLDER_KEY },
-            { tenant: "my-tenant" },
-        );
-    });
-
-    it("surfaces the SDK's not-found message as the failure", async () => {
-        vi.mocked(resolveFolder).mockRejectedValue(
-            new Error(`Folder not found: '${FOLDER_KEY}'.`),
-        );
-
-        expect(await resolveFolderIdByKey(FOLDER_KEY)).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: `Folder not found: '${FOLDER_KEY}'.`,
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-
-    it("reports a wire failure as an error resolving the key", async () => {
-        const wireError = Object.assign(new Error("HTTP 500"), {
-            response: { status: 500 },
-        });
-        vi.mocked(resolveFolder).mockRejectedValue(wireError);
-
-        expect(await resolveFolderIdByKey(FOLDER_KEY)).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: `Error resolving folder key '${FOLDER_KEY}'`,
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-});
-
-describe("resolveFolderIdByPath", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        process.exitCode = undefined;
-    });
-
-    it("resolves the folder id for a path", async () => {
-        vi.mocked(resolveFolder).mockResolvedValue(RESOLVED);
-
-        expect(await resolveFolderIdByPath("Shared/Finance")).toBe(42);
-        expect(resolveFolder).toHaveBeenCalledWith(
-            { folderPath: "Shared/Finance" },
-            { tenant: undefined },
-        );
-        expect(OutputFormatter.error).not.toHaveBeenCalled();
-    });
-
-    it("surfaces the SDK's not-found message as the failure", async () => {
-        vi.mocked(resolveFolder).mockRejectedValue(
-            new Error("Folder not found: 'Shared/Nope'."),
-        );
-
-        expect(await resolveFolderIdByPath("Shared/Nope")).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: "Folder not found: 'Shared/Nope'.",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-
-    it("reports a network failure as an error resolving the path", async () => {
-        const fetchError = new Error("socket hang up");
-        fetchError.name = "FetchError";
-        vi.mocked(resolveFolder).mockRejectedValue(fetchError);
-
-        expect(await resolveFolderIdByPath("Shared/Nope")).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: "Error resolving folder path 'Shared/Nope'",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-
-    it("reports not found when the resolver returns nothing", async () => {
-        vi.mocked(resolveFolder).mockResolvedValue(undefined);
-
-        expect(await resolveFolderIdByPath("Shared/Nope")).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Message: "Folder not found: 'Shared/Nope'.",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-});

package/src/commands/_shared/folder-resolver.ts

@@ -1,113 +0,0 @@
-import {
-    catchError,
-    extractErrorMessage,
-    isGuid,
-    OutputFormatter,
-    processContext,
-    RESULTS,
-} from "@uipath/common";
-import { resolveFolder } from "@uipath/orchestrator-sdk";
-
-const FOLDER_LOOKUP_HINT =
-    "Run 'uip or folders list' to see the folders you can access.";
-
-/**
- * Resolves --folder-path / --folder-key to the numeric folder id the tasks
- * API needs, through the SDK's shared resolveFolder — the same helper the
- * case/flow/maestro/orchestrator tools use. Its OData lookups work with a
- * regular user token (FoldersNavigation/GetFolderByKey does not — it 403s).
- * Lives in its own module, imported lazily from folder-picker, so the
- * FoldersApi chunk only loads when one of those flags is passed.
- *
- * Both resolvers return null when resolution fails (after emitting an error +
- * exit), so the caller can `return` early.
- */
-
-/**
- * resolveFolder throws a plain Error for user-input failures ("Folder not
- * found: ...") and ResponseError/FetchError for wire failures — the same
- * discrimination flow-tool's debug command uses.
- */
-function isFolderInputError(error: unknown): boolean {
-    if (!(error instanceof Error)) return false;
-    if ("response" in error) return false;
-    if (error.name === "FetchError") return false;
-    return true;
-}
-
-async function reportResolutionFailure(
-    scope: string,
-    error: unknown,
-): Promise<void> {
-    if (isFolderInputError(error)) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: (error as Error).message,
-            Instructions: FOLDER_LOOKUP_HINT,
-        });
-    } else {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Error resolving ${scope}`,
-            Instructions: `${await extractErrorMessage(error)} ${FOLDER_LOOKUP_HINT}`,
-        });
-    }
-    processContext.exit(1);
-}
-
-export async function resolveFolderIdByKey(
-    folderKey: string,
-    tenant?: string,
-): Promise<number | null> {
-    if (!isGuid(folderKey)) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Invalid --folder-key: ${folderKey}`,
-            Instructions:
-                "Expected a UUID (e.g. '12345678-1234-1234-1234-123456789abc').",
-        });
-        processContext.exit(1);
-        return null;
-    }
-
-    const [error, folder] = await catchError(
-        resolveFolder({ folderKey }, { tenant }),
-    );
-    if (error) {
-        await reportResolutionFailure(`folder key '${folderKey}'`, error);
-        return null;
-    }
-    if (folder?.id == null) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Folder not found: '${folderKey}'.`,
-            Instructions: FOLDER_LOOKUP_HINT,
-        });
-        processContext.exit(1);
-        return null;
-    }
-    return folder.id;
-}
-
-export async function resolveFolderIdByPath(
-    folderPath: string,
-    tenant?: string,
-): Promise<number | null> {
-    const [error, folder] = await catchError(
-        resolveFolder({ folderPath }, { tenant }),
-    );
-    if (error) {
-        await reportResolutionFailure(`folder path '${folderPath}'`, error);
-        return null;
-    }
-    if (folder?.id == null) {
-        OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: `Folder not found: '${folderPath}'.`,
-            Instructions: FOLDER_LOOKUP_HINT,
-        });
-        processContext.exit(1);
-        return null;
-    }
-    return folder.id;
-}

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

@@ -1,69 +0,0 @@
-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 { parseIntArg, parsePositiveInt, reportInvalidInt } from "./parse";
-
-describe("parsePositiveInt", () => {
-    it("accepts a positive integer", () => {
-        expect(parsePositiveInt("42", "<id>")).toEqual({
-            valid: true,
-            value: 42,
-        });
-    });
-
-    it.each(["0", "-1", "abc", "1.5", ""])("rejects %s", (value) => {
-        const result = parsePositiveInt(value, "--folder-id");
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.message).toBe(`Invalid --folder-id: ${value}`);
-            expect(result.instructions).toBe("Must be a positive integer.");
-        }
-    });
-});
-
-describe("reportInvalidInt", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        process.exitCode = undefined;
-    });
-
-    it("emits a failure and exits", () => {
-        reportInvalidInt({ message: "Invalid <id>: x", instructions: "nope" });
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Invalid <id>: x",
-                Instructions: "nope",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-});
-
-describe("parseIntArg", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        process.exitCode = undefined;
-    });
-
-    it("returns the number for a valid value", () => {
-        expect(parseIntArg("7", "<id>")).toBe(7);
-        expect(OutputFormatter.error).not.toHaveBeenCalled();
-    });
-
-    it("returns null and reports for an invalid value", () => {
-        expect(parseIntArg("nope", "--folder-id")).toBeNull();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({ Message: "Invalid --folder-id: nope" }),
-        );
-        expect(process.exitCode).toBe(1);
-    });
-});

package/src/commands/_shared/parse.ts

@@ -1,43 +0,0 @@
-import { OutputFormatter, processContext, RESULTS } from "@uipath/common";
-
-export type ParseResult =
-    | { valid: true; value: number }
-    | { valid: false; message: string; instructions: string };
-
-export function parsePositiveInt(value: string, label: string): ParseResult {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        return {
-            valid: false,
-            message: `Invalid ${label}: ${value}`,
-            instructions: "Must be a positive integer.",
-        };
-    }
-    return { valid: true, value: parsed };
-}
-
-export function reportInvalidInt(error: {
-    message: string;
-    instructions: string;
-}): void {
-    OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: error.message,
-        Instructions: error.instructions,
-    });
-    processContext.exit(1);
-}
-
-/**
- * Parses a positive-integer CLI argument. On an invalid value, emits the
- * standard error, exits with code 1, and returns null so the caller can
- * `return` early. Valid values are always > 0, so a null check is safe.
- */
-export function parseIntArg(value: string, label: string): number | null {
-    const parsed = parsePositiveInt(value, label);
-    if (!parsed.valid) {
-        reportInvalidInt(parsed);
-        return null;
-    }
-    return parsed.value;
-}