@stigmer/react 1.0.4 → 2.0.1

package/src/runner/__tests__/useLaunchLocalRunner.test.tsx

@@ -1,248 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { create } from "@bufbuild/protobuf";
-import { timestampFromDate } from "@bufbuild/protobuf/wkt";
-import { CreateLaunchTokenResponseSchema } from "@stigmer/protos/ai/stigmer/agentic/runner/v1/io_pb";
-import type { Stigmer } from "@stigmer/sdk";
-import { StigmerContext } from "../../context";
-import { useLaunchLocalRunner } from "../useLaunchLocalRunner";
-
-function buildMockClient(overrides: {
-  createLaunchToken?: ReturnType<typeof vi.fn>;
-} = {}) {
-  return {
-    runner: {
-      createLaunchToken:
-        overrides.createLaunchToken ?? vi.fn(),
-    },
-  } as unknown as Stigmer;
-}
-
-function makeWrapper(client: Stigmer) {
-  return ({ children }: { children: ReactNode }) => (
-    <StigmerContext.Provider value={client}>
-      {children}
-    </StigmerContext.Provider>
-  );
-}
-
-describe("useLaunchLocalRunner", () => {
-  const ORG = "test-org";
-
-  let createLaunchToken: ReturnType<typeof vi.fn>;
-  let client: Stigmer;
-
-  beforeEach(() => {
-    createLaunchToken = vi.fn();
-    client = buildMockClient({ createLaunchToken });
-  });
-
-  it("creates a token and opens the stigmer:// URL on success", async () => {
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok_abc123",
-      expiresAt: timestampFromDate(new Date()),
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    expect(result.current.isLaunching).toBe(false);
-    expect(result.current.error).toBeNull();
-    expect(result.current.lastLaunchResult).toBeNull();
-
-    let launchResult: Awaited<ReturnType<typeof result.current.launch>>;
-    await act(async () => {
-      launchResult = await result.current.launch({ org: ORG });
-    });
-
-    expect(createLaunchToken).toHaveBeenCalledOnce();
-    expect(openUrl).toHaveBeenCalledOnce();
-    expect(openUrl).toHaveBeenCalledWith(
-      `stigmer://launch-runner?token=${encodeURIComponent("tok_abc123")}`,
-    );
-
-    expect(launchResult!.url).toBe(
-      `stigmer://launch-runner?token=${encodeURIComponent("tok_abc123")}`,
-    );
-    expect(launchResult!.expiresAt).toBeInstanceOf(Date);
-
-    expect(result.current.isLaunching).toBe(false);
-    expect(result.current.error).toBeNull();
-    expect(result.current.lastLaunchResult).toEqual(launchResult!);
-  });
-
-  it("URL-encodes tokens with special characters", async () => {
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok/with+special=chars&more",
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await result.current.launch({ org: ORG });
-    });
-
-    const url = openUrl.mock.calls[0][0] as string;
-    expect(url).toContain(encodeURIComponent("tok/with+special=chars&more"));
-    expect(url).not.toContain("&more");
-  });
-
-  it("uses the custom openUrl callback", async () => {
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok_custom",
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    const customOpen = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl: customOpen }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await result.current.launch({ org: ORG });
-    });
-
-    expect(customOpen).toHaveBeenCalledOnce();
-    expect(customOpen.mock.calls[0][0]).toMatch(/^stigmer:\/\//);
-  });
-
-  it("returns undefined expiresAt when the server omits it", async () => {
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok_no_expiry",
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    let launchResult: Awaited<ReturnType<typeof result.current.launch>>;
-    await act(async () => {
-      launchResult = await result.current.launch({ org: ORG });
-    });
-
-    expect(launchResult!.expiresAt).toBeUndefined();
-  });
-
-  it("sets error and rethrows when createLaunchToken fails", async () => {
-    const rpcError = new Error("token creation failed");
-    createLaunchToken.mockRejectedValueOnce(rpcError);
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await expect(
-        result.current.launch({ org: ORG }),
-      ).rejects.toThrow("token creation failed");
-    });
-
-    expect(result.current.error).toBeInstanceOf(Error);
-    expect(result.current.error!.message).toBe("token creation failed");
-    expect(result.current.isLaunching).toBe(false);
-    expect(openUrl).not.toHaveBeenCalled();
-  });
-
-  it("handles non-Error rejection values", async () => {
-    createLaunchToken.mockRejectedValueOnce("string error");
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await expect(result.current.launch({ org: ORG })).rejects.toBe(
-        "string error",
-      );
-    });
-
-    expect(result.current.error).toBeInstanceOf(Error);
-    expect(result.current.error!.message).toBe("string error");
-  });
-
-  it("clears error via clearError", async () => {
-    createLaunchToken.mockRejectedValueOnce(new Error("fail"));
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await result.current.launch({ org: ORG }).catch(() => {});
-    });
-    expect(result.current.error).not.toBeNull();
-
-    act(() => {
-      result.current.clearError();
-    });
-    expect(result.current.error).toBeNull();
-  });
-
-  it("clearError also resets lastLaunchResult", async () => {
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok_clear",
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await result.current.launch({ org: ORG });
-    });
-    expect(result.current.lastLaunchResult).not.toBeNull();
-
-    act(() => {
-      result.current.clearError();
-    });
-    expect(result.current.lastLaunchResult).toBeNull();
-  });
-
-  it("resets previous error on a new successful launch", async () => {
-    createLaunchToken.mockRejectedValueOnce(new Error("first fail"));
-
-    const openUrl = vi.fn();
-    const { result } = renderHook(
-      () => useLaunchLocalRunner({ openUrl }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await act(async () => {
-      await result.current.launch({ org: ORG }).catch(() => {});
-    });
-    expect(result.current.error).not.toBeNull();
-
-    const response = create(CreateLaunchTokenResponseSchema, {
-      token: "tok_retry",
-    });
-    createLaunchToken.mockResolvedValueOnce(response);
-
-    await act(async () => {
-      await result.current.launch({ org: ORG });
-    });
-    expect(result.current.error).toBeNull();
-  });
-});

package/src/runner/__tests__/useRunnerFileBrowser.test.tsx

@@ -1,256 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import type { Stigmer } from "@stigmer/sdk";
-import { StigmerContext } from "../../context";
-import { useRunnerFileBrowser } from "../useRunnerFileBrowser";
-
-function buildListDirectoryResponse(
-  resolvedPath: string,
-  entries: Array<{ name: string; isDirectory: boolean; isHidden: boolean }>,
-  homeDirectory = "/home/user",
-  currentDirectory = "/home/user/projects",
-) {
-  return {
-    requestId: "req-1",
-    result: {
-      case: "listDirectory" as const,
-      value: {
-        resolvedPath,
-        entries: entries.map((e) => ({
-          name: e.name,
-          isDirectory: e.isDirectory,
-          isHidden: e.isHidden,
-          $typeName: "ai.stigmer.agentic.runner.v1.DirectoryEntry",
-        })),
-        homeDirectory,
-        currentDirectory,
-        $typeName: "ai.stigmer.agentic.runner.v1.ListDirectoryResponse",
-      },
-    },
-    $typeName: "ai.stigmer.agentic.runner.v1.RunnerCommandResponse",
-  };
-}
-
-function buildErrorResponse(message: string) {
-  return {
-    requestId: "req-1",
-    result: {
-      case: "error" as const,
-      value: {
-        message,
-        $typeName: "ai.stigmer.agentic.runner.v1.RunnerCommandError",
-      },
-    },
-    $typeName: "ai.stigmer.agentic.runner.v1.RunnerCommandResponse",
-  };
-}
-
-function buildMockClient(sendCommand: ReturnType<typeof vi.fn>) {
-  return {
-    runner: { sendCommand },
-  } as unknown as Stigmer;
-}
-
-function makeWrapper(client: Stigmer) {
-  return ({ children }: { children: ReactNode }) => (
-    <StigmerContext.Provider value={client}>
-      {children}
-    </StigmerContext.Provider>
-  );
-}
-
-describe("useRunnerFileBrowser", () => {
-  let sendCommandMock: ReturnType<typeof vi.fn>;
-  let client: Stigmer;
-
-  beforeEach(() => {
-    sendCommandMock = vi.fn();
-    client = buildMockClient(sendCommandMock);
-  });
-
-  it("fetches home directory on initial mount with runnerId", async () => {
-    sendCommandMock.mockResolvedValueOnce(
-      buildListDirectoryResponse("/home/user", [
-        { name: "projects", isDirectory: true, isHidden: false },
-        { name: ".config", isDirectory: true, isHidden: true },
-        { name: ".bashrc", isDirectory: false, isHidden: true },
-      ]),
-    );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(sendCommandMock).toHaveBeenCalledOnce();
-    expect(result.current.currentPath).toBe("/home/user");
-    expect(result.current.entries).toHaveLength(3);
-    expect(result.current.homeDirectory).toBe("/home/user");
-    expect(result.current.currentDirectory).toBe("/home/user/projects");
-    expect(result.current.segments).toHaveLength(3);
-    expect(result.current.segments[0].name).toBe("/");
-    expect(result.current.segments[2].name).toBe("user");
-  });
-
-  it("does not fetch when runnerId is null", () => {
-    renderHook(() => useRunnerFileBrowser(null), {
-      wrapper: makeWrapper(client),
-    });
-
-    expect(sendCommandMock).not.toHaveBeenCalled();
-  });
-
-  it("navigates into a child directory", async () => {
-    sendCommandMock
-      .mockResolvedValueOnce(
-        buildListDirectoryResponse("/home/user", [
-          { name: "projects", isDirectory: true, isHidden: false },
-        ]),
-      )
-      .mockResolvedValueOnce(
-        buildListDirectoryResponse("/home/user/projects", [
-          { name: "my-app", isDirectory: true, isHidden: false },
-        ]),
-      );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    await act(async () => {
-      result.current.navigateTo("projects");
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.currentPath).toBe("/home/user/projects");
-    expect(result.current.entries).toHaveLength(1);
-    expect(result.current.entries[0].name).toBe("my-app");
-  });
-
-  it("navigates up to parent directory", async () => {
-    sendCommandMock
-      .mockResolvedValueOnce(
-        buildListDirectoryResponse("/home/user/projects", []),
-      )
-      .mockResolvedValueOnce(
-        buildListDirectoryResponse("/home/user", [
-          { name: "projects", isDirectory: true, isHidden: false },
-        ]),
-      );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    await act(async () => {
-      result.current.navigateUp();
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.currentPath).toBe("/home/user");
-  });
-
-  it("handles runner error responses", async () => {
-    sendCommandMock.mockResolvedValueOnce(
-      buildErrorResponse("permission denied: /root"),
-    );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error!.message).toBe("permission denied: /root");
-  });
-
-  it("handles network errors", async () => {
-    sendCommandMock.mockRejectedValueOnce(new Error("runner unavailable"));
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error!.message).toBe("runner unavailable");
-  });
-
-  it("toggles hidden files", async () => {
-    sendCommandMock.mockResolvedValueOnce(
-      buildListDirectoryResponse("/home/user", []),
-    );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.showHidden).toBe(false);
-
-    act(() => {
-      result.current.toggleHidden();
-    });
-
-    expect(result.current.showHidden).toBe(true);
-
-    act(() => {
-      result.current.toggleHidden();
-    });
-
-    expect(result.current.showHidden).toBe(false);
-  });
-
-  it("retries the last failed request", async () => {
-    sendCommandMock
-      .mockRejectedValueOnce(new Error("timeout"))
-      .mockResolvedValueOnce(
-        buildListDirectoryResponse("/home/user", []),
-      );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.error).not.toBeNull());
-
-    await act(async () => {
-      result.current.retry();
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.error).toBeNull();
-    expect(result.current.currentPath).toBe("/home/user");
-    expect(sendCommandMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("reports isAtRoot correctly", async () => {
-    sendCommandMock.mockResolvedValueOnce(
-      buildListDirectoryResponse("/", [
-        { name: "home", isDirectory: true, isHidden: false },
-      ]),
-    );
-
-    const { result } = renderHook(() => useRunnerFileBrowser("rnr_1"), {
-      wrapper: makeWrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.isAtRoot).toBe(true);
-  });
-});

package/src/runner/__tests__/useRunnerList.test.tsx

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { create } from "@bufbuild/protobuf";
-import {
-  RunnerSchema,
-  RunnerStatusSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/runner/v1/api_pb";
-import { RunnerPhase } from "@stigmer/protos/ai/stigmer/agentic/runner/v1/enum_pb";
-import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
-import type { Stigmer } from "@stigmer/sdk";
-import { StigmerContext } from "../../context";
-import { useRunnerList } from "../useRunnerList";
-
-function makeRunner(id: string, name: string, phase: RunnerPhase) {
-  const runner = create(RunnerSchema);
-  runner.metadata = create(ApiResourceMetadataSchema);
-  runner.metadata.id = id;
-  runner.metadata.name = name;
-  runner.status = create(RunnerStatusSchema);
-  runner.status.phase = phase;
-  return runner;
-}
-
-function buildMockClient(listMock: ReturnType<typeof vi.fn>) {
-  return {
-    runner: { list: listMock },
-  } as unknown as Stigmer;
-}
-
-function makeWrapper(client: Stigmer) {
-  return ({ children }: { children: ReactNode }) => (
-    <StigmerContext.Provider value={client}>
-      {children}
-    </StigmerContext.Provider>
-  );
-}
-
-async function flush(): Promise<void> {
-  await act(async () => {
-    await Promise.resolve();
-  });
-}
-
-describe("useRunnerList — refetchInterval", () => {
-  let listMock: ReturnType<typeof vi.fn>;
-  let client: Stigmer;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    listMock = vi.fn();
-    client = buildMockClient(listMock);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("polls when refetchInterval is set", async () => {
-    const runners = [makeRunner("r1", "dev", RunnerPhase.PENDING)];
-    listMock.mockResolvedValue({ items: runners });
-
-    const { result } = renderHook(
-      () => useRunnerList("acme", { refetchInterval: 2000 }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    // Initial fetch.
-    await flush();
-    expect(listMock).toHaveBeenCalledTimes(1);
-    expect(result.current.runners).toHaveLength(1);
-
-    // Advance by one interval.
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(2000);
-    });
-    expect(listMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("does not poll when refetchInterval is false", async () => {
-    listMock.mockResolvedValue({ items: [] });
-
-    renderHook(
-      () => useRunnerList("acme", { refetchInterval: false }),
-      { wrapper: makeWrapper(client) },
-    );
-
-    await flush();
-    expect(listMock).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(10_000);
-    });
-    expect(listMock).toHaveBeenCalledTimes(1);
-  });
-});