@stigmer/react 3.2.3 → 3.4.0

package/src/cursor-accounts/__tests__/cursor-account-coverage.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import {
+  CursorAccountSyncSnapshotSchema,
+  CursorMemberKeySchema,
+  CursorMemberSpendSchema,
+  CursorTeamMemberSchema,
+} from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/cursor_account_pb";
+import {
+  CursorAccountViewSchema,
+  CursorMemberKeyState,
+  CursorMemberKeyViewSchema,
+  CursorTeamMemberViewSchema,
+} from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+import { deriveCoverage } from "../cursor-account-coverage";
+
+function keyView(keyId: string, state: CursorMemberKeyState) {
+  return create(CursorMemberKeyViewSchema, {
+    key: create(CursorMemberKeySchema, { keyId, boundEmail: `${keyId}@x.ai` }),
+    state,
+  });
+}
+
+describe("deriveCoverage", () => {
+  it("groups keys by server-computed state and passes coverage-gap rows through", () => {
+    const active = keyView("k-active", CursorMemberKeyState.member_key_active);
+    const removed = keyView("k-removed", CursorMemberKeyState.member_key_owner_removed);
+    const stranger = keyView("k-stranger", CursorMemberKeyState.member_key_owner_unknown);
+    const gap = create(CursorTeamMemberViewSchema, {
+      member: create(CursorTeamMemberSchema, { email: "uncovered@x.ai", role: "member" }),
+      spend: create(CursorMemberSpendSchema, { includedSpendUsdMicros: BigInt(42_000) }),
+    });
+
+    const coverage = deriveCoverage(
+      create(CursorAccountViewSchema, {
+        snapshot: create(CursorAccountSyncSnapshotSchema, { accountId: "acc-1" }),
+        keyViews: [active, removed, stranger],
+        membersWithoutKeysViews: [gap],
+      }),
+    );
+
+    expect(coverage.hasRoster).toBe(true);
+    expect(coverage.onTeamWithKey).toEqual([active]);
+    expect(coverage.onTeamWithoutKey).toEqual([gap]);
+    // Both "left the team" and "never on it" resolve the same way (a
+    // Cursor dashboard invite), so they share the category; the per-key
+    // state still distinguishes their labels.
+    expect(coverage.offTeamWithKey).toEqual([removed, stranger]);
+    expect(coverage.unclassified).toEqual([]);
+  });
+
+  it("withholds classification before the first sync — owner-unknown is missing data, not off-team", () => {
+    const key = keyView("k-1", CursorMemberKeyState.member_key_owner_unknown);
+
+    const coverage = deriveCoverage(
+      create(CursorAccountViewSchema, { keyViews: [key] }),
+    );
+
+    expect(coverage.hasRoster).toBe(false);
+    expect(coverage.unclassified).toEqual([key]);
+    expect(coverage.onTeamWithKey).toEqual([]);
+    expect(coverage.onTeamWithoutKey).toEqual([]);
+    expect(coverage.offTeamWithKey).toEqual([]);
+  });
+
+  it("handles the empty account (no keys, no roster) without inventing rows", () => {
+    const coverage = deriveCoverage(create(CursorAccountViewSchema, {}));
+
+    expect(coverage.hasRoster).toBe(false);
+    expect(coverage.unclassified).toEqual([]);
+    expect(coverage.onTeamWithKey).toEqual([]);
+  });
+});

package/src/cursor-accounts/badges.tsx

@@ -0,0 +1,26 @@
+import { cn } from "@stigmer/theme";
+
+/**
+ * Small tonal status badge shared by the cursor-accounts surfaces
+ * (account rows, coverage table cells). Internal to the module.
+ */
+export function StateBadge({
+  tone,
+  label,
+}: {
+  readonly tone: "ok" | "warn" | "muted";
+  readonly label: string;
+}) {
+  return (
+    <span
+      className={cn(
+        "inline-block rounded px-1.5 py-0.5 text-[10px] font-medium",
+        tone === "ok" && "bg-accent text-primary",
+        tone === "warn" && "bg-muted-subtle text-destructive",
+        tone === "muted" && "bg-muted-subtle text-muted-foreground",
+      )}
+    >
+      {label}
+    </span>
+  );
+}

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

@@ -0,0 +1,71 @@
+import {
+  CursorMemberKeyState,
+  type CursorAccountView,
+  type CursorMemberKeyView,
+  type CursorTeamMemberView,
+} from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+
+/**
+ * The account's roster coverage, grouped for the operator table. Pure
+ * regrouping of server-computed facts — the membership classification
+ * (`CursorMemberKeyState`) and the spend joins are computed by the
+ * backend on read (the same email rule key selection uses); this module
+ * must never re-derive them from emails or role strings.
+ */
+export interface CursorAccountCoverage {
+  /**
+   * Whether a roster snapshot backs the classification. Before the first
+   * sync every key reports "owner unknown" — that is missing data, not
+   * "not on the team", so classification is withheld (`unclassified`)
+   * until a sync has run.
+   */
+  readonly hasRoster: boolean;
+  /** On the team, execution key held — the account's routable capacity. */
+  readonly onTeamWithKey: readonly CursorMemberKeyView[];
+  /**
+   * On the team, no execution key — the coverage gap. Sessions can never
+   * run under these members' identities or included quotas. Spend comes
+   * server-joined so the operator can prioritize whose key to import.
+   */
+  readonly onTeamWithoutKey: readonly CursorTeamMemberView[];
+  /**
+   * Key held, owner not on the team: either left it (roster role
+   * "removed") or never appeared in the roster — the per-key state
+   * distinguishes the two. Resolving this category means inviting the
+   * owner on the Cursor dashboard; the next sync reclassifies.
+   */
+  readonly offTeamWithKey: readonly CursorMemberKeyView[];
+  /** Every key, only while no roster snapshot exists (empty otherwise). */
+  readonly unclassified: readonly CursorMemberKeyView[];
+}
+
+/**
+ * Group one account view into the three coverage categories (plus the
+ * pre-first-sync "unclassified" holding state). Server order is
+ * preserved within each group.
+ */
+export function deriveCoverage(view: CursorAccountView): CursorAccountCoverage {
+  const hasRoster = view.snapshot !== undefined;
+
+  if (!hasRoster) {
+    return {
+      hasRoster,
+      onTeamWithKey: [],
+      onTeamWithoutKey: [],
+      offTeamWithKey: [],
+      unclassified: view.keyViews,
+    };
+  }
+
+  return {
+    hasRoster,
+    onTeamWithKey: view.keyViews.filter(
+      (kv) => kv.state === CursorMemberKeyState.member_key_active,
+    ),
+    onTeamWithoutKey: view.membersWithoutKeysViews,
+    offTeamWithKey: view.keyViews.filter(
+      (kv) => kv.state !== CursorMemberKeyState.member_key_active,
+    ),
+    unclassified: [],
+  };
+}

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

@@ -0,0 +1,45 @@
+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
+// pricing-governance 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",
+  });
+}
+
+/**
+ * Cursor's pool-usage percent (0–100, live-verified) to a display string
+ * (`26.97` → `"27%"`, `0` → `"0%"`).
+ *
+ * Zero renders as "0%", matching Cursor's own Members page. An earlier
+ * revision suppressed it on the theory that Cursor only omits percent
+ * fields on non-tiered teams (so a stored 0 meant "unreported") — live
+ * data falsified that: Cursor also omits them for zero-usage members on
+ * tiered Team plans, where its dashboard shows "0%". The "unreported"
+ * signal is the absence of the member's whole spend row (the caller's
+ * em-dash case), not a zero field inside one.
+ */
+export function formatPoolPercent(percent: number): string {
+  return `${Math.round(percent)}%`;
+}

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 };
+}

package/src/cursor-accounts/useDeleteCursorAccount.ts

@@ -0,0 +1,62 @@
+"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 {@link useDeleteCursorAccount}. */
+export interface DeleteCursorAccountInput {
+  readonly accountId: string;
+  /**
+   * Deletion is refused (FAILED_PRECONDITION) while live sessions are
+   * pinned to the account's keys. `force: true` overrides — their Cursor
+   * agent handles will be orphaned at disposal. Prefer disabling the
+   * account, which is always safe.
+   */
+  readonly force?: boolean;
+}
+
+/** Return value of {@link useDeleteCursorAccount}. */
+export interface UseDeleteCursorAccountReturn {
+  /** Delete the account (plus its snapshots and session pins). */
+  readonly remove: (input: DeleteCursorAccountInput) => Promise<CursorAccount>;
+  /** `true` while a delete 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 for deleting a managed Cursor account. The live-pin
+ * guard's FAILED_PRECONDITION message carries the pinned session count —
+ * surface it verbatim so the operator can choose disable-instead.
+ */
+export function useDeleteCursorAccount(): UseDeleteCursorAccountReturn {
+  const stigmer = useStigmer();
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const remove = useCallback(
+    async (input: DeleteCursorAccountInput): Promise<CursorAccount> => {
+      setIsSubmitting(true);
+      setError(null);
+      try {
+        return await stigmer.cursorAccounts.deleteAccount(input);
+      } catch (e) {
+        const err = toError(e);
+        setError(err);
+        throw err;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [stigmer.cursorAccounts],
+  );
+
+  const clearError = useCallback(() => setError(null), []);
+
+  return { remove, isSubmitting, error, clearError };
+}

package/src/cursor-accounts/useSyncCursorAccount.ts

@@ -0,0 +1,54 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { CursorAccountView } from "@stigmer/protos/ai/stigmer/platform/cursoraccount/v1/io_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useSyncCursorAccount}. */
+export interface UseSyncCursorAccountReturn {
+  /**
+   * Run an on-demand roster + spend sync and return the refreshed view.
+   * The Cursor Admin API is rate-limited (20 req/min, poll-hourly
+   * guidance) — `isSyncing` should disable the trigger while in flight,
+   * and callers should not poll this.
+   */
+  readonly sync: (accountId: string) => Promise<CursorAccountView>;
+  /** `true` while a sync is in flight. */
+  readonly isSyncing: boolean;
+  /** Error from the last failed attempt, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook for the console's "Sync now" — the same server-side sync
+ * the hourly schedule runs, on demand.
+ */
+export function useSyncCursorAccount(): UseSyncCursorAccountReturn {
+  const stigmer = useStigmer();
+  const [isSyncing, setIsSyncing] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const sync = useCallback(
+    async (accountId: string): Promise<CursorAccountView> => {
+      setIsSyncing(true);
+      setError(null);
+      try {
+        return await stigmer.cursorAccounts.syncAccount(accountId);
+      } catch (e) {
+        const err = toError(e);
+        setError(err);
+        throw err;
+      } finally {
+        setIsSyncing(false);
+      }
+    },
+    [stigmer.cursorAccounts],
+  );
+
+  const clearError = useCallback(() => setError(null), []);
+
+  return { sync, isSyncing, error, clearError };
+}

package/src/cursor-accounts/useUpsertCursorAccount.ts

@@ -0,0 +1,57 @@
+"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";
+
+/** Return value of {@link useUpsertCursorAccount}. */
+export interface UseUpsertCursorAccountReturn {
+  /**
+   * Create (empty `accountId`) or update a Cursor account. The admin key
+   * is plaintext to set/rotate or the `***REDACTED***` marker to keep the
+   * stored value; the server validates new keys live against Cursor's
+   * `/teams/members` before persisting. Returns the redacted account.
+   */
+  readonly upsert: (account: CursorAccount) => Promise<CursorAccount>;
+  /** `true` while a save 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 for creating or updating a managed Cursor account.
+ *
+ * The parent should refetch its list/detail view after a successful
+ * save — org assignments affect key selection within the proxy's cache
+ * TTL (~5 minutes).
+ */
+export function useUpsertCursorAccount(): UseUpsertCursorAccountReturn {
+  const stigmer = useStigmer();
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const upsert = useCallback(
+    async (account: CursorAccount): Promise<CursorAccount> => {
+      setIsSubmitting(true);
+      setError(null);
+      try {
+        return await stigmer.cursorAccounts.upsertAccount({ account });
+      } catch (e) {
+        const err = toError(e);
+        setError(err);
+        throw err;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [stigmer.cursorAccounts],
+  );
+
+  const clearError = useCallback(() => setError(null), []);
+
+  return { upsert, isSubmitting, error, clearError };
+}