@uipath/coder-tool 1.202.0-preview.141 → 1.202.0-preview.143

package/src/commands/chat.spec.ts

@@ -1,224 +0,0 @@
-import { Command } from "commander";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@earendil-works/pi-coding-agent", () => ({
-    main: vi.fn(),
-}));
-
-vi.mock("../providers/uipath", () => ({
-    createUiPathProviderExtension: vi.fn(() => ({
-        name: "uipath-llm-gateway",
-        factory: vi.fn(),
-    })),
-}));
-
-let guideExists = true;
-const GUIDE_TEXT = "# UiPath CLI (`uip`) — agent guidance\n(test copy)";
-vi.mock("@uipath/filesystem", () => ({
-    getFileSystem: () => ({
-        exists: (path: string) =>
-            Promise.resolve(guideExists && path.includes("uipath-cli.md")),
-        readFile: () => Promise.resolve(GUIDE_TEXT),
-    }),
-}));
-
-import { main } from "@earendil-works/pi-coding-agent";
-import { OutputFormatter } from "@uipath/common";
-import { registerChatCommand, withAgentGuide } from "./chat";
-
-function buildProgram(context?: { exit: (code: number) => void }): Command {
-    const program = new Command();
-    program.name("coder").exitOverride();
-    registerChatCommand(program, context, vi.fn());
-    return program;
-}
-
-function piArgs(): string[] {
-    return (vi.mocked(main).mock.calls[0]?.[0] ?? []) as string[];
-}
-
-describe("uip coder", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        guideExists = true;
-        process.exitCode = undefined;
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    it("launches pi with the UiPath agent guide appended to the system prompt", async () => {
-        const program = buildProgram();
-
-        await program.parseAsync([], { from: "user" });
-
-        expect(main).toHaveBeenCalledTimes(1);
-        const args = piArgs();
-        expect(args[0]).toBe("--append-system-prompt");
-        // The guide is passed as text, not a file path, so the injection
-        // does not depend on Pi's file-or-literal argument resolution.
-        expect(args[1]).toBe(GUIDE_TEXT);
-        expect(args).toHaveLength(2);
-    });
-
-    it("forwards positional arguments and unknown options to pi", async () => {
-        const program = buildProgram();
-
-        await program.parseAsync(
-            ["-p", "--provider", "uipath", "--model", "gpt-4o", "hello"],
-            { from: "user" },
-        );
-
-        expect(piArgs().slice(2)).toEqual([
-            "-p",
-            "--provider",
-            "uipath",
-            "--model",
-            "gpt-4o",
-            "hello",
-        ]);
-    });
-
-    it("launches pi without the guide when the template is missing", async () => {
-        guideExists = false;
-        const program = buildProgram();
-
-        await program.parseAsync(["-p", "hi"], { from: "user" });
-
-        expect(piArgs()).toEqual(["-p", "hi"]);
-    });
-
-    it("does not inject the guide before pi package-management subcommands", () => {
-        expect(withAgentGuide(["install", "some-ext"], "/guide.md")).toEqual([
-            "install",
-            "some-ext",
-        ]);
-        expect(withAgentGuide(["-p", "hi"], "/guide.md")).toEqual([
-            "--append-system-prompt",
-            "/guide.md",
-            "-p",
-            "hi",
-        ]);
-    });
-
-    it("keeps the guide for prompts whose first word matches a subcommand name", () => {
-        // Pi routes package commands on args[0] only, so an unquoted prompt
-        // like `-p update the readme` is a prompt, not `pi update`.
-        expect(
-            withAgentGuide(["-p", "update", "the", "readme"], "/guide.md"),
-        ).toEqual([
-            "--append-system-prompt",
-            "/guide.md",
-            "-p",
-            "update",
-            "the",
-            "readme",
-        ]);
-    });
-
-    it("passes the uipath provider extension to pi", async () => {
-        const program = buildProgram();
-
-        await program.parseAsync([], { from: "user" });
-
-        const [, options] = vi.mocked(main).mock.calls[0] ?? [];
-        const factories =
-            (options as { extensionFactories?: unknown[] })
-                ?.extensionFactories ?? [];
-        expect(factories).toHaveLength(1);
-        expect(factories[0]).toMatchObject({ name: "uipath-llm-gateway" });
-    });
-
-    it("turns pi's non-zero process.exit into a failure envelope", async () => {
-        const errorSpy = vi
-            .spyOn(OutputFormatter, "error")
-            .mockImplementation(() => {});
-        vi.mocked(main).mockImplementation(async () => {
-            // Pi hard-exits on its own error paths instead of throwing.
-            process.exit(2);
-        });
-        const exit = vi.fn();
-        const program = buildProgram({ exit });
-
-        await program.parseAsync(["-p", "hi"], { from: "user" });
-
-        expect(errorSpy).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: expect.stringContaining("exited with code 2"),
-            }),
-        );
-        expect(exit).toHaveBeenCalledWith(2);
-    });
-
-    it("handles process.exit from a fire-and-forget shutdown without an unhandled rejection", async () => {
-        // Pi's interactive quit (Ctrl+C / Ctrl+D) calls process.exit(0) from
-        // a floating promise chain, not from main()'s awaited stack.
-        const rejections: unknown[] = [];
-        const onRejection = (reason: unknown) => rejections.push(reason);
-        process.on("unhandledRejection", onRejection);
-        vi.mocked(main).mockImplementation(
-            () =>
-                new Promise<void>(() => {
-                    // never resolves — like an interactive session
-                    setTimeout(() => {
-                        void Promise.resolve().then(() => process.exit(0));
-                    }, 0);
-                }),
-        );
-        const exit = vi.fn();
-        const program = buildProgram({ exit });
-
-        await program.parseAsync([], { from: "user" });
-        await new Promise((resolve) => setImmediate(resolve));
-
-        process.off("unhandledRejection", onRejection);
-        expect(rejections).toEqual([]);
-        expect(exit).not.toHaveBeenCalled();
-    });
-
-    it("treats pi's process.exit(0) as success", async () => {
-        const errorSpy = vi
-            .spyOn(OutputFormatter, "error")
-            .mockImplementation(() => {});
-        vi.mocked(main).mockImplementation(async () => {
-            process.exit(0);
-        });
-        const exit = vi.fn();
-        const program = buildProgram({ exit });
-
-        await program.parseAsync(["-p", "hi"], { from: "user" });
-
-        expect(errorSpy).not.toHaveBeenCalled();
-        expect(exit).not.toHaveBeenCalled();
-    });
-
-    it("restores process.exit after pi finishes", async () => {
-        const originalExit = process.exit;
-        const program = buildProgram();
-
-        await program.parseAsync([], { from: "user" });
-
-        expect(process.exit).toBe(originalExit);
-    });
-
-    it("reports a failure envelope and exits 1 when pi fails to start", async () => {
-        const errorSpy = vi
-            .spyOn(OutputFormatter, "error")
-            .mockImplementation(() => {});
-        vi.mocked(main).mockRejectedValueOnce(new Error("pi exploded"));
-        const exit = vi.fn();
-        const program = buildProgram({ exit });
-
-        await program.parseAsync([], { from: "user" });
-
-        expect(errorSpy).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: expect.stringContaining("pi exploded"),
-            }),
-        );
-        expect(exit).toHaveBeenCalledWith(1);
-    });
-});

package/src/commands/chat.ts

@@ -1,156 +0,0 @@
-import { fileURLToPath } from "node:url";
-import {
-    type CommandContext,
-    OutputFormatter,
-    processContext,
-    RESULTS,
-} from "@uipath/common";
-import { getFileSystem } from "@uipath/filesystem";
-import type { Command } from "commander";
-import { createUiPathProviderExtension } from "../providers/uipath";
-
-/**
- * Pi package-management subcommands. They must stay the first argv token,
- * and they don't start an agent session, so no system prompt is injected.
- */
-const PI_SUBCOMMANDS = new Set([
-    "install",
-    "remove",
-    "uninstall",
-    "update",
-    "list",
-    "config",
-]);
-
-/**
- * Load the bundled UiPath CLI guide appended to Pi's system prompt.
- * Lives at dist/templates/ in the published package (copied by
- * tools/build-tool.ts) and at the package root when running from source.
- * Returns the guide TEXT (not the path) so the injection does not depend
- * on Pi's file-or-literal resolution of `--append-system-prompt`.
- */
-export async function resolveAgentGuide(): Promise<string | undefined> {
-    const fs = getFileSystem();
-    const candidates = [
-        new URL("./templates/uipath-cli.md", import.meta.url),
-        new URL("../../templates/uipath-cli.md", import.meta.url),
-    ];
-    for (const url of candidates) {
-        const path = fileURLToPath(url);
-        if (await fs.exists(path)) {
-            const text = await fs.readFile(path, "utf-8");
-            return text ?? undefined;
-        }
-    }
-    return undefined;
-}
-
-/**
- * Prepend `--append-system-prompt <guide>` so the agent knows how to drive
- * the UiPath platform through `uip`. Skipped for Pi's package-management
- * subcommands, which Pi routes on the first argv token only — a prompt like
- * `-p update the readme` must still get the guide.
- */
-export function withAgentGuide(
-    args: string[],
-    guideText: string | undefined,
-): string[] {
-    if (!guideText) {
-        return args;
-    }
-    const first = args[0];
-    if (first !== undefined && PI_SUBCOMMANDS.has(first)) {
-        return args;
-    }
-    return ["--append-system-prompt", guideText, ...args];
-}
-
-type HardExit = (code: number) => void;
-
-/**
- * Run Pi's CLI entry point with `process.exit` intercepted. Pi hard-exits
- * on both success and failure (deliberately, so misbehaving extensions
- * cannot keep one-shot commands alive); the interception turns that into a
- * return value so failures can be reported through the CLI envelope. The
- * hard exit is re-applied after the command finishes its bookkeeping.
- *
- * The interception resolves a promise instead of throwing: Pi's interactive
- * quit paths (Ctrl+C / Ctrl+D / signal handlers) call `process.exit` from
- * fire-and-forget shutdown chains, where a throw would surface as an
- * unhandled rejection instead of a clean exit.
- */
-async function runPi(args: string[], hardExit?: HardExit): Promise<number> {
-    const { main } = await import("@earendil-works/pi-coding-agent");
-    const originalExit = process.exit;
-    let requestedExitCode: number | undefined;
-    let resolveExit: (code: number) => void = () => {};
-    const exitRequested = new Promise<number>((resolve) => {
-        resolveExit = resolve;
-    });
-    process.exit = ((code?: number | string | null) => {
-        requestedExitCode =
-            typeof code === "number" ? code : (process.exitCode ?? 0);
-        resolveExit(requestedExitCode);
-        return undefined as never;
-    }) as typeof process.exit;
-    try {
-        const mainDone = main(args, {
-            extensionFactories: [createUiPathProviderExtension()],
-        }).then(() => requestedExitCode ?? 0);
-        // If main settles after an exit was already requested, that outcome
-        // has nowhere to go — swallow it so it cannot become an unhandled
-        // rejection. The raced result below already carries the exit code.
-        mainDone.catch(() => {});
-        return await Promise.race([mainDone, exitRequested]);
-    } finally {
-        process.exit = originalExit;
-        // Preserve Pi's lifecycle: force the exit once telemetry and output
-        // (which run in microtasks before I/O callbacks) have completed.
-        const exit: HardExit = hardExit ?? ((code) => originalExit(code));
-        setImmediate(() => exit(process.exitCode ?? requestedExitCode ?? 0));
-    }
-}
-
-/**
- * `uip coder [args...]` — the UiPath coding agent, powered by Pi.
- *
- * All arguments are forwarded verbatim to Pi, so the full Pi CLI surface
- * stays available: no args opens the interactive TUI; `-p "<prompt>"` runs
- * one prompt and exits; `--list-models` shows every provider/model;
- * `--provider uipath --model <id>` pins the UiPath LLM Gateway;
- * `--continue` resumes the previous session. See `uip coder --help`
- * (rendered by Pi) for everything else.
- */
-export function registerChatCommand(
-    command: Command,
-    context: CommandContext = processContext,
-    hardExit?: HardExit,
-): void {
-    command
-        .argument(
-            "[args...]",
-            "arguments forwarded to the Pi coding agent (see 'uip coder --help')",
-        )
-        .allowUnknownOption()
-        .allowExcessArguments(true)
-        .helpOption(false)
-        .trackedAction(
-            context,
-            async (_args: string[], _options: unknown, cmd: Command) => {
-                const guide = await resolveAgentGuide();
-                const exitCode = await runPi(
-                    withAgentGuide(cmd.args, guide),
-                    hardExit,
-                );
-                if (exitCode !== 0) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `The coding agent exited with code ${exitCode}.`,
-                        Instructions:
-                            "Check the agent output above for the underlying error. Run 'uip coder --help' for usage, or 'uip login' if the uipath provider is missing.",
-                    });
-                    context.exit(exitCode);
-                }
-            },
-        );
-}

package/src/index.ts

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Standalone entry point for coder-tool
- * This allows the tool to be run independently for testing
- */
-
-// Side-effect import: installs Command.prototype.trackedAction on this
-// bundle's commander copy before registerCommands touches it.
-import { setPreviewBuild } from "@uipath/common";
-import { Command } from "commander";
-import { metadata, registerCommands } from "./tool.js";
-
-// The standalone bin is a dev/test surface — opt into the preview-gated
-// command unconditionally. The CLI host gates on its own release channel.
-setPreviewBuild(true);
-
-const program = new Command();
-
-program
-    .name(metadata.commandPrefix)
-    .description(metadata.description)
-    .version(metadata.version);
-
-await registerCommands(program);
-
-program.parse(process.argv);

package/src/providers/uipath.spec.ts

@@ -1,296 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@uipath/auth", () => ({
-    getLoginStatusAsync: vi.fn(),
-}));
-
-vi.mock("@uipath/common", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("@uipath/common")>();
-    return {
-        ...actual,
-        logger: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-});
-
-import { getLoginStatusAsync } from "@uipath/auth";
-import { createUiPathProviderExtension, UIPATH_PROVIDER_ID } from "./uipath";
-
-type EventHandler = (event: unknown) => Promise<unknown>;
-
-function buildFakePi() {
-    const handlers = new Map<string, EventHandler>();
-    return {
-        registerProvider: vi.fn(),
-        on: vi.fn((event: string, handler: EventHandler) => {
-            handlers.set(event, handler);
-        }),
-        handlers,
-    };
-}
-
-function loggedInStatus(expiresInMs: number) {
-    return {
-        loginStatus: "Logged in" as const,
-        accessToken: "header.payload.signature",
-        baseUrl: "https://cloud.uipath.com",
-        organizationId: "org-id",
-        organizationName: "myorg",
-        tenantName: "mytenant",
-        expiration: new Date(Date.now() + expiresInMs),
-    };
-}
-
-describe("createUiPathProviderExtension", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        vi.unstubAllGlobals();
-    });
-
-    it("skips registration when not logged in", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue({
-            loginStatus: "Not logged in",
-        });
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        expect(pi.registerProvider).not.toHaveBeenCalled();
-        expect(pi.on).not.toHaveBeenCalled();
-    });
-
-    it("registers discovered models against the agenthub_ gateway route", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({
-                ok: true,
-                json: () =>
-                    Promise.resolve({
-                        supportedModels: [
-                            {
-                                model: "gpt-4o-2024-11-20",
-                                contextWindow: 128000,
-                            },
-                            "gpt-4o-mini-2024-07-18",
-                        ],
-                    }),
-            }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        expect(pi.registerProvider).toHaveBeenCalledWith(
-            UIPATH_PROVIDER_ID,
-            expect.objectContaining({
-                name: "UiPath LLM Gateway",
-                api: "openai-completions",
-                apiKey: "header.payload.signature",
-                baseUrl:
-                    "https://cloud.uipath.com/org-id/mytenant/agenthub_/llm/openai",
-            }),
-        );
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string; baseUrl: string }>;
-        };
-        expect(config.models).toHaveLength(2);
-        expect(config.models[0]?.baseUrl).toBe(
-            "https://cloud.uipath.com/org-id/mytenant/agenthub_/llm/openai/deployments/gpt-4o-2024-11-20",
-        );
-    });
-
-    it("accepts a bare-array discovery response", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve(["gpt-4o-2024-11-20"]),
-            }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string }>;
-        };
-        expect(config.models.map((m) => m.id)).toEqual(["gpt-4o-2024-11-20"]);
-    });
-
-    it("falls back to default models when discovery returns null", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve(null),
-            }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string }>;
-        };
-        expect(config.models.length).toBeGreaterThan(0);
-    });
-
-    it("passes a timeout signal to the discovery request", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 404 });
-        vi.stubGlobal("fetch", fetchMock);
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const init = fetchMock.mock.calls[0]?.[1] as { signal?: AbortSignal };
-        expect(init.signal).toBeInstanceOf(AbortSignal);
-    });
-
-    it("falls back to default models when discovery fails", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({ ok: false, status: 404 }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string }>;
-        };
-        expect(config.models.length).toBeGreaterThan(0);
-    });
-
-    it("encodes model ids when building deployment routes", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({
-                ok: true,
-                json: () =>
-                    Promise.resolve({ supportedModels: ["openai/gpt-4o"] }),
-            }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string; baseUrl: string }>;
-        };
-        expect(config.models[0]?.id).toBe("openai/gpt-4o");
-        expect(config.models[0]?.baseUrl).toBe(
-            "https://cloud.uipath.com/org-id/mytenant/agenthub_/llm/openai/deployments/openai%2Fgpt-4o",
-        );
-    });
-
-    it("skips registration when resolving the login status fails", async () => {
-        vi.mocked(getLoginStatusAsync).mockRejectedValue(
-            new Error("auth file unreadable"),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        expect(pi.registerProvider).not.toHaveBeenCalled();
-    });
-
-    it("falls back to default models when discovery returns an unusable shape", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({ unexpected: true }),
-            }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            models: Array<{ id: string }>;
-        };
-        expect(config.models.length).toBeGreaterThan(0);
-    });
-
-    it("uses organizationName in the gateway path when organizationId is missing", async () => {
-        const status = loggedInStatus(60 * 60 * 1000);
-        vi.mocked(getLoginStatusAsync).mockResolvedValue({
-            ...status,
-            organizationId: undefined,
-        });
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({ ok: false, status: 404 }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-
-        const config = vi.mocked(pi.registerProvider).mock.calls[0]?.[1] as {
-            baseUrl: string;
-        };
-        expect(config.baseUrl).toBe(
-            "https://cloud.uipath.com/myorg/mytenant/agenthub_/llm/openai",
-        );
-    });
-
-    it("does not re-register on agent_start while the token is fresh", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({ ok: false, status: 404 }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-        expect(pi.registerProvider).toHaveBeenCalledTimes(1);
-
-        await pi.handlers.get("agent_start")?.({ type: "agent_start" });
-
-        expect(pi.registerProvider).toHaveBeenCalledTimes(1);
-        expect(getLoginStatusAsync).toHaveBeenCalledTimes(1);
-    });
-
-    it("re-registers with a fresh token on agent_start when close to expiry", async () => {
-        vi.mocked(getLoginStatusAsync).mockResolvedValue(
-            loggedInStatus(60 * 1000),
-        );
-        vi.stubGlobal(
-            "fetch",
-            vi.fn().mockResolvedValue({ ok: false, status: 404 }),
-        );
-        const pi = buildFakePi();
-
-        await createUiPathProviderExtension().factory(pi as never);
-        expect(pi.registerProvider).toHaveBeenCalledTimes(1);
-
-        const handler = pi.handlers.get("agent_start");
-        expect(handler).toBeDefined();
-        await handler?.({ type: "agent_start" });
-
-        expect(pi.registerProvider).toHaveBeenCalledTimes(2);
-        expect(getLoginStatusAsync).toHaveBeenCalledTimes(2);
-    });
-});