@uipath/tasks-tool 1.200.0-preview.120 → 1.201.0-preview.121

package/tests/metadata.e2e.test.ts

@@ -0,0 +1,186 @@
+import { RESULTS } from "@uipath/common";
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    EXEC_TIMEOUT,
+    localCliRaw,
+    localCliRawWithArgs,
+    parseOutput,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+interface Envelope {
+    Result: string;
+    Code?: string;
+    Message?: string;
+    Instructions?: string;
+}
+
+interface TaskRow {
+    Id?: number;
+    IsDeleted?: boolean;
+    Status?: string;
+    Type?: string;
+    FolderId?: number;
+}
+
+const { tempDir } = readManifest<E2EManifest>(MANIFEST_PATH).sharedInstall;
+
+function listTasks(asAdmin: boolean): TaskRow[] {
+    const flag = asAdmin ? "--as-admin " : "";
+    const raw = localCliRaw(
+        tempDir,
+        `tasks list ${flag}--limit 200 --output json`,
+    );
+    if (raw.exitCode !== 0) return [];
+    return (parseOutput(raw.stdout, "json") as { Data?: TaskRow[] }).Data ?? [];
+}
+
+function discoverTask(): { taskId: string; folderId: string } | null {
+    const envFolder = process.env.TASKS_TOOL_E2E_FOLDER_ID;
+    const envTask =
+        process.env.TASKS_TOOL_E2E_TASK_ID_METADATA ??
+        process.env.TASKS_TOOL_E2E_TASK_ID;
+    if (envFolder && envTask) {
+        return { taskId: envTask, folderId: envFolder };
+    }
+    for (const asAdmin of [false, true]) {
+        const task = listTasks(asAdmin).find(
+            (t) =>
+                !t.IsDeleted &&
+                t.Status !== "Completed" &&
+                t.Type === "ExternalTask" &&
+                typeof t.Id === "number" &&
+                typeof t.FolderId === "number",
+        );
+        if (task) {
+            return {
+                taskId: String(task.Id),
+                folderId: String(envFolder ?? task.FolderId),
+            };
+        }
+    }
+    // No actionable ExternalTask on this tenant; skip the live suite (guarded by describe.skipIf below).
+    return null;
+}
+
+const discovered = discoverTask();
+const taskId = discovered?.taskId ?? "";
+const folderId = discovered?.folderId ?? "";
+
+function editMetadata(id: string, flags: string[]): Envelope {
+    const raw = localCliRawWithArgs(tempDir, [
+        "tasks",
+        "metadata",
+        id,
+        "--folder-id",
+        folderId,
+        ...flags,
+        "--output",
+        "json",
+    ]);
+    return parseOutput(raw.stdout, "json") as Envelope;
+}
+
+describe.skipIf(!discovered)("tasks metadata e2e", () => {
+    it(
+        "S1: edit title and priority together",
+        () => {
+            const res = editMetadata(taskId, [
+                "--title",
+                "Review invoice",
+                "--priority",
+                "High",
+            ]);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskMetadataEdited");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S2: invalid task id reports a validation error",
+        () => {
+            const res = editMetadata("not-a-number", ["--title", "x"]);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid <task-id>/);
+            expect(res.Instructions).toBe("Must be a positive integer.");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S3: invalid priority reports a validation error",
+        () => {
+            const res = editMetadata(taskId, ["--priority", "Urgent"]);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Invalid priority/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S4: edit a non-existent task reports a failure",
+        () => {
+            const res = editMetadata("999999999", ["--title", "x"]);
+            expect(res.Result).toBe(RESULTS.Failure);
+            expect(res.Message).toMatch(/^Error editing metadata on task/);
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S5: edit only the title",
+        () => {
+            const res = editMetadata(taskId, [
+                "--title",
+                `sdk-cli-e2e-title-${Date.now()}`,
+            ]);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskMetadataEdited");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S6: edit only the priority",
+        () => {
+            const res = editMetadata(taskId, ["--priority", "Low"]);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskMetadataEdited");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S7: attach an edit note",
+        () => {
+            const res = editMetadata(taskId, ["--note", "reclassified"]);
+            expect(res.Result).toBe(RESULTS.Success);
+            expect(res.Code).toBe("TaskMetadataEdited");
+        },
+        EXEC_TIMEOUT,
+    );
+
+    it(
+        "S8: a retitle is reflected on the task",
+        () => {
+            const title = `sdk-cli-e2e-retitle-${Date.now()}`;
+            const edit = editMetadata(taskId, ["--title", title]);
+            expect(edit.Result).toBe(RESULTS.Success);
+
+            const getRaw = localCliRaw(
+                tempDir,
+                `tasks get ${taskId} --output json`,
+            );
+            const task = parseOutput(getRaw.stdout, "json") as {
+                Data?: { Title?: string };
+            };
+            expect(task.Data?.Title).toBe(title);
+        },
+        EXEC_TIMEOUT,
+    );
+});

package/dist/node-strategy-a4n0d6dx.js

@@ -1,63 +0,0 @@
-import {
-  catchError,
-  getFileSystem,
-  startServer
-} from "./tool-q90kqh83.js";
-import"./tool-1ps2qeqg.js";
-import"./tool-0v6na3yp.js";
-
-// ../auth/src/strategies/node-strategy.ts
-class NodeAuthStrategy {
-  async execute(url, redirectUri, expectedState, opts) {
-    const fs = getFileSystem();
-    const callbackUrl = await startServer({
-      redirectUri,
-      timeoutMs: opts?.timeoutMs,
-      signal: opts?.signal,
-      onListening: async () => {
-        let safeUrl = "";
-        for (const ch of url) {
-          const c = ch.charCodeAt(0);
-          if (c > 31 && (c < 128 || c > 159))
-            safeUrl += ch;
-        }
-        if (opts?.noBrowser) {
-          if (!opts.onAuthUrl) {
-            throw new Error("Headless login (noBrowser) requires an onAuthUrl handler " + "to surface the authorize URL, but none was provided.");
-          }
-          opts.onAuthUrl(safeUrl);
-          return;
-        }
-        const [openError] = await catchError(fs.utils.open(url));
-        if (!openError)
-          return;
-        const isSpawnError = "code" in openError && openError.code === "ENOENT";
-        if (isSpawnError) {
-          throw new Error("Could not open a browser. No supported browser launcher was found. " + `On a headless or minimal system, use non-interactive login instead:
-
-` + `  uip login --client-id <id> --client-secret <secret> -t <tenant>
-
-` + "Or install a browser opener for your OS (e.g. xdg-utils on Linux).", { cause: openError });
-        }
-        throw new Error("Could not open the browser automatically. " + `Visit this URL to authenticate:
-
-  ${safeUrl}
-`, { cause: openError });
-      }
-    });
-    const returnedState = callbackUrl.searchParams.get("state");
-    if (returnedState !== expectedState) {
-      throw new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again.");
-    }
-    const code = callbackUrl.searchParams.get("code");
-    if (!code) {
-      throw new Error("No authorization code received");
-    }
-    return code;
-  }
-}
-export {
-  NodeAuthStrategy
-};
-
-//# debugId=E5B2BD2B3B179D3D64756E2164756E21