@stigmer/react 3.2.2 → 3.3.0

package/src/cursor-accounts/__tests__/CursorAccountsConsole.test.tsx

@@ -0,0 +1,384 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { StigmerError } from "@stigmer/sdk";
+import {
+  CursorAccountSchema,
+  CursorMemberKeySchema,
+  CursorTeamMemberSchema,
+  CursorMemberSpendSchema,
+  CursorAccountSyncSnapshotSchema,
+} from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/cursor_account_pb";
+import {
+  CursorAccountSummarySchema,
+  CursorAccountViewSchema,
+  CursorMemberKeyViewSchema,
+  CursorMemberKeyState,
+} from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { CursorAccountsConsole } from "../CursorAccountsConsole";
+
+interface MockCursorAccounts {
+  listAccounts: ReturnType<typeof vi.fn>;
+  getAccountView: ReturnType<typeof vi.fn>;
+  upsertAccount: ReturnType<typeof vi.fn>;
+  deleteAccount: ReturnType<typeof vi.fn>;
+  addMemberKey: ReturnType<typeof vi.fn>;
+  removeMemberKey: ReturnType<typeof vi.fn>;
+  setMemberKeyEnabled: ReturnType<typeof vi.fn>;
+  syncAccount: ReturnType<typeof vi.fn>;
+}
+
+function createMockStigmer(cursorAccounts: Partial<MockCursorAccounts> = {}) {
+  return {
+    cursorAccounts: {
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [] }),
+      getAccountView: vi.fn(),
+      upsertAccount: vi.fn(),
+      deleteAccount: vi.fn(),
+      addMemberKey: vi.fn(),
+      removeMemberKey: vi.fn(),
+      setMemberKeyEnabled: vi.fn(),
+      syncAccount: vi.fn(),
+      ...cursorAccounts,
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+function scenarAccount(overrides: Record<string, unknown> = {}) {
+  return create(CursorAccountSchema, {
+    accountId: "acc-1",
+    displayName: "scenar team",
+    adminApiKey: "***REDACTED***",
+    enabled: true,
+    orgIds: ["org-a"],
+    memberKeys: [
+      create(CursorMemberKeySchema, {
+        keyId: "k-1",
+        apiKey: "***REDACTED***",
+        boundEmail: "zane@scenar.ai",
+        cursorKeyName: "stigmer-prod",
+        enabled: true,
+      }),
+    ],
+    ...overrides,
+  });
+}
+
+function scenarSummary() {
+  return create(CursorAccountSummarySchema, {
+    account: scenarAccount(),
+    enabledKeyCount: 1,
+    lastSyncedAt: timestampFromDate(new Date("2026-07-22T12:00:00Z")),
+  });
+}
+
+function scenarView() {
+  return create(CursorAccountViewSchema, {
+    account: scenarAccount(),
+    snapshot: create(CursorAccountSyncSnapshotSchema, {
+      accountId: "acc-1",
+      syncedAt: timestampFromDate(new Date("2026-07-22T12:00:00Z")),
+      members: [
+        create(CursorTeamMemberSchema, {
+          userId: "u1",
+          email: "zane@scenar.ai",
+          name: "Zane S",
+          role: "owner",
+        }),
+        create(CursorTeamMemberSchema, {
+          userId: "u2",
+          email: "uncovered@scenar.ai",
+          name: "Uncovered U",
+          role: "member",
+        }),
+      ],
+      spend: [
+        create(CursorMemberSpendSchema, {
+          userId: "u1",
+          email: "zane@scenar.ai",
+          includedSpendUsdMicros: 169342n,
+        }),
+      ],
+    }),
+    keyViews: [
+      create(CursorMemberKeyViewSchema, {
+        key: scenarAccount().memberKeys[0],
+        state: CursorMemberKeyState.member_key_active,
+        spend: create(CursorMemberSpendSchema, {
+          userId: "u1",
+          email: "zane@scenar.ai",
+          includedSpendUsdMicros: 169342n,
+        }),
+      }),
+    ],
+    membersWithoutKeys: [
+      create(CursorTeamMemberSchema, {
+        userId: "u2",
+        email: "uncovered@scenar.ai",
+        name: "Uncovered U",
+        role: "member",
+      }),
+    ],
+  });
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("CursorAccountsConsole", () => {
+  it("renders the empty state with onboarding guidance", async () => {
+    const client = createMockStigmer();
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() =>
+      expect(screen.getByText(/No Cursor accounts yet/)).toBeTruthy(),
+    );
+  });
+
+  it("lists accounts with routability at a glance", async () => {
+    const notRoutable = create(CursorAccountSummarySchema, {
+      account: scenarAccount({
+        accountId: "acc-2",
+        displayName: "empty team",
+        memberKeys: [],
+        orgIds: [],
+        isPlatformDefault: true,
+      }),
+      enabledKeyCount: 0,
+    });
+    const client = createMockStigmer({
+      listAccounts: vi
+        .fn()
+        .mockResolvedValue({ accounts: [scenarSummary(), notRoutable] }),
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    expect(screen.getByText("empty team")).toBeTruthy();
+    expect(screen.getByText("Not routable")).toBeTruthy();
+    expect(screen.getByText("platform default")).toBeTruthy();
+  });
+
+  it("shows the designed access notice on PERMISSION_DENIED", async () => {
+    const client = createMockStigmer({
+      listAccounts: vi
+        .fn()
+        .mockRejectedValue(
+          new StigmerError("permission-denied", "only platform operators", 7),
+        ),
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() =>
+      expect(screen.getByText("Platform operator access required")).toBeTruthy(),
+    );
+    expect(screen.queryByText(/only platform operators/)).toBeNull();
+  });
+
+  it("opens the detail view with key coverage, spend, and gap list", async () => {
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [scenarSummary()] }),
+      getAccountView: vi.fn().mockResolvedValue(scenarView()),
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: /scenar team/ }));
+
+    await waitFor(() => expect(screen.getByText(/zane@scenar\.ai/)).toBeTruthy());
+    // Spend joined to the key row: 169342 micro-USD = $0.17.
+    expect(screen.getByText(/\$0\.17 this cycle/)).toBeTruthy();
+    // Coverage gap: the active member with no key, by name and email.
+    expect(screen.getByText(/uncovered@scenar\.ai/)).toBeTruthy();
+    expect(screen.getByText("Active")).toBeTruthy();
+  });
+
+  it("adds a member key and refreshes both views", async () => {
+    const addMemberKey = vi.fn().mockResolvedValue(scenarAccount());
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [scenarSummary()] }),
+      getAccountView: vi.fn().mockResolvedValue(scenarView()),
+      addMemberKey,
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: /scenar team/ }));
+    await waitFor(() =>
+      expect(screen.getByLabelText(/User-scoped API key/)).toBeTruthy(),
+    );
+
+    await userEvent.type(
+      screen.getByLabelText(/User-scoped API key/),
+      "key_user_plain",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Add key" }));
+
+    await waitFor(() =>
+      expect(addMemberKey).toHaveBeenCalledWith({
+        accountId: "acc-1",
+        apiKey: "key_user_plain",
+        label: undefined,
+      }),
+    );
+  });
+
+  it("surfaces Cursor's own explanation when a wrong key class is added", async () => {
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [scenarSummary()] }),
+      getAccountView: vi.fn().mockResolvedValue(scenarView()),
+      addMemberKey: vi
+        .fn()
+        .mockRejectedValue(
+          new StigmerError(
+            "invalid-argument",
+            "Key rejected by Cursor — This is a team API key from the dashboard's Team API Keys tab",
+            3,
+          ),
+        ),
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: /scenar team/ }));
+    await waitFor(() =>
+      expect(screen.getByLabelText(/User-scoped API key/)).toBeTruthy(),
+    );
+
+    await userEvent.type(screen.getByLabelText(/User-scoped API key/), "wrong-class");
+    await userEvent.click(screen.getByRole("button", { name: "Add key" }));
+
+    await waitFor(() =>
+      expect(screen.getByText(/Team API Keys tab/i)).toBeTruthy(),
+    );
+  });
+
+  it("creates an account through the editor", async () => {
+    const upsertAccount = vi.fn().mockResolvedValue(scenarAccount());
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [] }),
+      upsertAccount,
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() =>
+      expect(screen.getByRole("button", { name: "Add account" })).toBeTruthy(),
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Add account" }));
+
+    await userEvent.type(screen.getByLabelText(/Display name/), "new team");
+    await userEvent.type(
+      screen.getByLabelText(/Team Admin API key/),
+      "key_admin_plain",
+    );
+    await userEvent.type(
+      screen.getByLabelText(/Assigned organization ids/),
+      "org-x org-y",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Create account" }));
+
+    await waitFor(() => expect(upsertAccount).toHaveBeenCalledTimes(1));
+    const submitted = upsertAccount.mock.calls[0][0].account;
+    expect(submitted.displayName).toBe("new team");
+    expect(submitted.adminApiKey).toBe("key_admin_plain");
+    expect(submitted.orgIds).toEqual(["org-x", "org-y"]);
+    expect(submitted.enabled).toBe(true);
+  });
+
+  it("bulk-imports keys one per line, keeping failed lines for retry", async () => {
+    const accountWithNewKey = scenarAccount({
+      memberKeys: [
+        scenarAccount().memberKeys[0],
+        create(CursorMemberKeySchema, {
+          keyId: "k-new",
+          apiKey: "***REDACTED***",
+          boundEmail: "morgan@scenar.ai",
+          enabled: true,
+        }),
+      ],
+    });
+    const addMemberKey = vi
+      .fn()
+      .mockResolvedValueOnce(accountWithNewKey)
+      .mockRejectedValueOnce(
+        new StigmerError("invalid-argument", "Key rejected by Cursor", 3),
+      );
+    const syncAccount = vi.fn().mockResolvedValue(scenarView());
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [scenarSummary()] }),
+      getAccountView: vi.fn().mockResolvedValue(scenarView()),
+      addMemberKey,
+      syncAccount,
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: /scenar team/ }));
+    await waitFor(() =>
+      expect(screen.getByRole("button", { name: "Import keys" })).toBeTruthy(),
+    );
+
+    await userEvent.click(screen.getByRole("button", { name: "Import keys" }));
+    const textarea = screen.getByLabelText(/one user-scoped API key per line/);
+    await userEvent.type(textarea, "key_good_1234{Enter}key_bad_5678");
+    await userEvent.click(screen.getByRole("button", { name: "Import 2 keys" }));
+
+    await waitFor(() => expect(addMemberKey).toHaveBeenCalledTimes(2));
+    expect(addMemberKey).toHaveBeenNthCalledWith(1, {
+      accountId: "acc-1",
+      apiKey: "key_good_1234",
+    });
+    expect(addMemberKey).toHaveBeenNthCalledWith(2, {
+      accountId: "acc-1",
+      apiKey: "key_bad_5678",
+    });
+
+    // Per-line outcomes: success bound to its member, failure with the error.
+    await waitFor(() =>
+      expect(screen.getByText(/added — bound to morgan@scenar\.ai/)).toBeTruthy(),
+    );
+    expect(screen.getByText(/Key rejected by Cursor/)).toBeTruthy();
+    // Only the failed key remains in the box for retry.
+    expect((textarea as HTMLTextAreaElement).value).toBe("key_bad_5678");
+    // The roster sync runs automatically after the import.
+    await waitFor(() => expect(syncAccount).toHaveBeenCalledWith("acc-1"));
+  });
+
+  it("keeps the stored admin key when the editor's masked value is untouched", async () => {
+    const upsertAccount = vi.fn().mockResolvedValue(scenarAccount());
+    const client = createMockStigmer({
+      listAccounts: vi.fn().mockResolvedValue({ accounts: [scenarSummary()] }),
+      getAccountView: vi.fn().mockResolvedValue(scenarView()),
+      upsertAccount,
+    });
+    render(<CursorAccountsConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => expect(screen.getByText("scenar team")).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: /scenar team/ }));
+    await waitFor(() => expect(screen.getByRole("button", { name: "Edit" })).toBeTruthy());
+    await userEvent.click(screen.getByRole("button", { name: "Edit" }));
+
+    await userEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(upsertAccount).toHaveBeenCalledTimes(1));
+    expect(upsertAccount.mock.calls[0][0].account.adminApiKey).toBe("***REDACTED***");
+  });
+});

package/src/cursor-accounts/cursor-account-format.ts

@@ -0,0 +1,29 @@
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+
+// BigInt literals (0n) require an ES2020 target, which not every consuming
+// app's tsconfig guarantees — the constructor form is target-agnostic (the
+// billing pricing-format precedent).
+const ZERO = BigInt(0);
+
+/**
+ * Micro-USD to a display dollar string (e.g. `169342n` → `"$0.17"`).
+ * Spend figures are Cursor-reported cycle totals — two decimals is the
+ * honest precision for a monitoring surface.
+ */
+export function formatSpendMicros(micros: bigint): string {
+  const dollars = Number(micros) / 1_000_000;
+  return `$${dollars.toFixed(2)}`;
+}
+
+/** Proto Timestamp to a compact local date-time (e.g. "Jul 22, 14:05"). */
+export function formatSyncTime(ts: Timestamp | undefined): string {
+  if (!ts || ts.seconds === ZERO) {
+    return "never";
+  }
+  return new Date(Number(ts.seconds) * 1000).toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}

package/src/cursor-accounts/index.ts

@@ -0,0 +1,29 @@
+// Data hooks
+export { useCursorAccounts } from "./useCursorAccounts.js";
+export type { UseCursorAccountsReturn } from "./useCursorAccounts.js";
+export { useCursorAccountView } from "./useCursorAccountView.js";
+export type { UseCursorAccountViewReturn } from "./useCursorAccountView.js";
+
+// Behavior hooks
+export { useUpsertCursorAccount } from "./useUpsertCursorAccount.js";
+export type { UseUpsertCursorAccountReturn } from "./useUpsertCursorAccount.js";
+export { useDeleteCursorAccount } from "./useDeleteCursorAccount.js";
+export type {
+  DeleteCursorAccountInput,
+  UseDeleteCursorAccountReturn,
+} from "./useDeleteCursorAccount.js";
+export { useCursorMemberKeyActions } from "./useCursorMemberKeyActions.js";
+export type {
+  AddCursorMemberKeyInput,
+  RemoveCursorMemberKeyInput,
+  UseCursorMemberKeyActionsReturn,
+} from "./useCursorMemberKeyActions.js";
+export { useSyncCursorAccount } from "./useSyncCursorAccount.js";
+export type { UseSyncCursorAccountReturn } from "./useSyncCursorAccount.js";
+
+// Styled components
+export { CursorAccountsConsole } from "./CursorAccountsConsole.js";
+export type { CursorAccountsConsoleProps } from "./CursorAccountsConsole.js";
+export { CursorAccountEditor } from "./CursorAccountEditor.js";
+export type { CursorAccountEditorProps } from "./CursorAccountEditor.js";
+export { CursorAccountsAccessNotice } from "./CursorAccountsAccessNotice.js";

package/src/cursor-accounts/useCursorAccountView.ts

@@ -0,0 +1,49 @@
+"use client";
+
+import type { CursorAccountView } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+
+/** Return value of {@link useCursorAccountView}. */
+export interface UseCursorAccountViewReturn {
+  /** The detail view, or `null` before the first successful fetch. */
+  readonly view: CursorAccountView | null;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight and stale data is shown. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch from the server. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Data hook for one Cursor account's detail view: the redacted account,
+ * the latest roster/spend snapshot, and the server-computed coverage
+ * join (per-key owner state and cycle spend, active members without
+ * keys).
+ *
+ * Pass `null` as `accountId` to skip fetching (e.g. while the console is
+ * on the list phase).
+ *
+ * @example
+ * ```tsx
+ * const { view, isLoading, refetch } = useCursorAccountView(accountId);
+ * ```
+ */
+export function useCursorAccountView(
+  accountId: string | null,
+): UseCursorAccountViewReturn {
+  const stigmer = useStigmer();
+
+  const { data: view, isLoading, isRefetching, error, refetch } = useFetch(
+    accountId
+      ? () => stigmer.cursorAccounts.getAccountView(accountId)
+      : null,
+    [accountId, stigmer],
+    null as CursorAccountView | null,
+  );
+
+  return { view, isLoading, isRefetching, error, refetch };
+}

package/src/cursor-accounts/useCursorAccounts.ts

@@ -0,0 +1,49 @@
+"use client";
+
+import type { CursorAccountsResponse } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+
+/** Return value of {@link useCursorAccounts}. */
+export interface UseCursorAccountsReturn {
+  /** The account summaries, or `null` before the first successful fetch. */
+  readonly accounts: CursorAccountsResponse | null;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight and stale data is shown. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch from the server. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Data hook that lists every managed Cursor account with its routing and
+ * sync summary (enabled member key count, last-synced timestamp). Key
+ * material is always redacted server-side.
+ *
+ * Platform-operator surface: the caller needs
+ * `can_manage_cursor_accounts` on `platform:stigmer`.
+ *
+ * Pass `enabled: false` to skip fetching (stable no-op).
+ *
+ * @example
+ * ```tsx
+ * const { accounts, isLoading, refetch } = useCursorAccounts();
+ * ```
+ */
+export function useCursorAccounts(
+  options?: { readonly enabled?: boolean },
+): UseCursorAccountsReturn {
+  const stigmer = useStigmer();
+  const enabled = options?.enabled ?? true;
+
+  const { data: accounts, isLoading, isRefetching, error, refetch } = useFetch(
+    enabled ? () => stigmer.cursorAccounts.listAccounts() : null,
+    [enabled, stigmer],
+    null as CursorAccountsResponse | null,
+  );
+
+  return { accounts, isLoading, isRefetching, error, refetch };
+}

package/src/cursor-accounts/useCursorMemberKeyActions.ts

@@ -0,0 +1,106 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { CursorAccount } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/cursor_account_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Input for adding one member key. */
+export interface AddCursorMemberKeyInput {
+  readonly accountId: string;
+  /**
+   * Plaintext user-scoped Cursor API key. The server identifies it via
+   * Cursor's `/v1/me` and binds it to its owning team member; admin and
+   * service-account keys are rejected with Cursor's own explanation —
+   * surface the error verbatim.
+   */
+  readonly apiKey: string;
+  /** Optional operator label. */
+  readonly label?: string;
+}
+
+/** Input for removing one member key. */
+export interface RemoveCursorMemberKeyInput {
+  readonly accountId: string;
+  readonly keyId: string;
+  /**
+   * Removal is refused while live sessions are pinned to this key.
+   * `force: true` overrides; prefer disabling (always safe).
+   */
+  readonly force?: boolean;
+}
+
+/** Return value of {@link useCursorMemberKeyActions}. */
+export interface UseCursorMemberKeyActionsReturn {
+  /** Add one execution-capable member key. Returns the redacted account. */
+  readonly addKey: (input: AddCursorMemberKeyInput) => Promise<CursorAccount>;
+  /** Remove one member key (live-pin guarded). */
+  readonly removeKey: (input: RemoveCursorMemberKeyInput) => Promise<CursorAccount>;
+  /** Enable/disable one key for NEW-session selection (pins unaffected). */
+  readonly setKeyEnabled: (
+    accountId: string,
+    keyId: string,
+    enabled: boolean,
+  ) => Promise<CursorAccount>;
+  /** `true` while any key mutation is in flight. */
+  readonly isSubmitting: boolean;
+  /** Error from the last failed attempt, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook bundling the member-key mutations of one Cursor account —
+ * add, remove, enable/disable. One hook because the console's key panel
+ * performs all three and they share submit/error surfaces.
+ *
+ * Rotation is deliberately remove + add (no in-place key swap), so the
+ * server-side `/v1/me` identity binding can never go stale.
+ */
+export function useCursorMemberKeyActions(): UseCursorMemberKeyActionsReturn {
+  const stigmer = useStigmer();
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const run = useCallback(
+    async (op: () => Promise<CursorAccount>): Promise<CursorAccount> => {
+      setIsSubmitting(true);
+      setError(null);
+      try {
+        return await op();
+      } catch (e) {
+        const err = toError(e);
+        setError(err);
+        throw err;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [],
+  );
+
+  const addKey = useCallback(
+    (input: AddCursorMemberKeyInput) =>
+      run(() => stigmer.cursorAccounts.addMemberKey(input)),
+    [run, stigmer.cursorAccounts],
+  );
+
+  const removeKey = useCallback(
+    (input: RemoveCursorMemberKeyInput) =>
+      run(() => stigmer.cursorAccounts.removeMemberKey(input)),
+    [run, stigmer.cursorAccounts],
+  );
+
+  const setKeyEnabled = useCallback(
+    (accountId: string, keyId: string, enabled: boolean) =>
+      run(() =>
+        stigmer.cursorAccounts.setMemberKeyEnabled({ accountId, keyId, enabled }),
+      ),
+    [run, stigmer.cursorAccounts],
+  );
+
+  const clearError = useCallback(() => setError(null), []);
+
+  return { addKey, removeKey, setKeyEnabled, isSubmitting, error, clearError };
+}