@stigmer/react 3.5.2 → 3.6.0

package/src/schedule/useSetScheduleEnabled.ts

@@ -0,0 +1,84 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import { clone } from "@bufbuild/protobuf";
+import {
+  ScheduleSchema,
+  type Schedule,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { getUserMessage, manifestDocumentForResource } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toast } from "../feedback/toast.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useSetScheduleEnabled}. */
+export interface UseSetScheduleEnabledReturn {
+  /**
+   * Flip the owner's `spec.enabled` switch. Takes the full fetched
+   * schedule (not just an id) because the write re-applies the whole
+   * resource. Resolves with the post-apply schedule; the caller
+   * refetches or replaces its local copy from it.
+   */
+  readonly setEnabled: (schedule: Schedule, enabled: boolean) => Promise<Schedule>;
+  /** `true` while the apply is in flight. */
+  readonly isPending: boolean;
+  /** Error from the last failed apply, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook that flips a schedule's owner-controlled `enabled` flag.
+ *
+ * The write path is deliberate: clone the fetched proto, flip one
+ * field, and re-apply the WHOLE resource through the manifest engine
+ * (`stigmer.manifest.apply`) — never down-convert to the curated
+ * `ScheduleInput` shape. The server replaces spec and mutable metadata
+ * wholesale on update, and `ScheduleInput` cannot express every
+ * metadata field (tags, description), so the input route would silently
+ * wipe them. The full-proto route is lossless by construction; the
+ * server ignores client-provided status, and re-applying never clears a
+ * platform pause (Resume is the one clearing path — see
+ * {@link useResumeSchedule}).
+ */
+export function useSetScheduleEnabled(): UseSetScheduleEnabledReturn {
+  const stigmer = useStigmer();
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const setEnabled = useCallback(
+    async (schedule: Schedule, enabled: boolean): Promise<Schedule> => {
+      if (!schedule.spec) {
+        throw new Error(
+          "Cannot toggle this schedule: it has no spec. Pass a schedule " +
+            "as returned by the server (get/getByReference).",
+        );
+      }
+
+      setIsPending(true);
+      setError(null);
+      try {
+        const updated = clone(ScheduleSchema, schedule);
+        updated.spec!.enabled = enabled;
+
+        const applied = await stigmer.manifest.apply(
+          manifestDocumentForResource(updated),
+        );
+        toast.success(enabled ? "Schedule enabled" : "Schedule disabled");
+        return applied.message as Schedule;
+      } catch (err) {
+        const wrapped = toError(err);
+        setError(wrapped);
+        toast.error(getUserMessage(err));
+        throw wrapped;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return useMemo(
+    () => ({ setEnabled, isPending, error }),
+    [setEnabled, isPending, error],
+  );
+}

package/src/schedule/useTriggerSchedule.ts

@@ -0,0 +1,65 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { getUserMessage } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toast } from "../feedback/toast.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useTriggerSchedule}. */
+export interface UseTriggerScheduleReturn {
+  /**
+   * Fire the schedule once, now — a real agent execution, outside the
+   * cron cadence. Resolves with the post-trigger schedule; refetch to
+   * pick up the new `status.last_execution_id`.
+   */
+  readonly triggerSchedule: (scheduleId: string) => Promise<Schedule>;
+  /** `true` while the trigger request is in flight. */
+  readonly isTriggering: boolean;
+  /** Error from the last failed or refused trigger, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook that fires a schedule once, immediately.
+ *
+ * The server enforces a refusal matrix — a disabled schedule refuses
+ * first, then a paused one — both as `FAILED_PRECONDITION` with copy
+ * that names the remedy ("enable it before triggering" / "resume it
+ * before triggering"). Error toasts relay that copy verbatim; the copy
+ * is byte-identical across editions.
+ *
+ * Triggering starts a real, billable execution — gate the call behind a
+ * confirmation (the detail view uses `ConfirmDialog`).
+ */
+export function useTriggerSchedule(): UseTriggerScheduleReturn {
+  const stigmer = useStigmer();
+  const [isTriggering, setIsTriggering] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const triggerSchedule = useCallback(
+    async (scheduleId: string): Promise<Schedule> => {
+      setIsTriggering(true);
+      setError(null);
+      try {
+        const triggered = await stigmer.schedule.trigger(scheduleId);
+        toast.success("Run started");
+        return triggered;
+      } catch (err) {
+        const wrapped = toError(err);
+        setError(wrapped);
+        toast.error(getUserMessage(err));
+        throw wrapped;
+      } finally {
+        setIsTriggering(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return useMemo(
+    () => ({ triggerSchedule, isTriggering, error }),
+    [triggerSchedule, isTriggering, error],
+  );
+}

package/src/search/__tests__/useResourceCount.test.tsx

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ListParams, ListResult } from "@stigmer/sdk";
+import { useResourceCount } from "../useResourceCount";
+
+function mockListFn(totalCount = 0) {
+  return vi.fn<(params: ListParams) => Promise<ListResult>>().mockResolvedValue({
+    entries: [],
+    totalCount,
+    totalPages: totalCount > 0 ? 1 : 0,
+  } as never);
+}
+
+describe("useResourceCount", () => {
+  it("counts in org scope by default: org sent, crossOrgPublic false", async () => {
+    const listFn = mockListFn(7);
+
+    const { result } = renderHook(() => useResourceCount(listFn, "acme"));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.count).toBe(7);
+    const params = listFn.mock.calls[0][0];
+    expect(params.org).toBe("acme");
+    expect(params.crossOrgPublic).toBe(false);
+    expect(params.page).toEqual({ num: 1, size: 1 });
+  });
+
+  it('always sends org in "all" scope (empty org means a cross-org FGA dump to the backend)', async () => {
+    const listFn = mockListFn(3);
+
+    const { result } = renderHook(() =>
+      useResourceCount(listFn, "acme", { scope: "all" }),
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    const params = listFn.mock.calls[0][0];
+    // Regression guard: the pre-fix hook blanked org for "all", which the
+    // search backend defines as "every org the caller can access" — the
+    // Library cards then counted platform-wide instead of org + public.
+    expect(params.org).toBe("acme");
+    expect(params.crossOrgPublic).toBe(true);
+  });
+
+  it("does not fetch when org is null", async () => {
+    const listFn = mockListFn();
+
+    const { result } = renderHook(() => useResourceCount(listFn, null));
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(listFn).not.toHaveBeenCalled();
+    expect(result.current.count).toBeUndefined();
+  });
+
+  it("recounts when refetchToken changes", async () => {
+    const listFn = mockListFn(1);
+
+    const { result, rerender } = renderHook(
+      ({ token }: { token: number }) =>
+        useResourceCount(listFn, "acme", { refetchToken: token }),
+      { initialProps: { token: 0 } },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(listFn).toHaveBeenCalledTimes(1);
+
+    rerender({ token: 1 });
+
+    await waitFor(() => expect(listFn).toHaveBeenCalledTimes(2));
+  });
+
+  it("refetches with the new org when the org changes", async () => {
+    const listFn = mockListFn(2);
+
+    const { result, rerender } = renderHook(
+      ({ org }: { org: string }) => useResourceCount(listFn, org),
+      { initialProps: { org: "acme" } },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    rerender({ org: "globex" });
+
+    await waitFor(() => expect(listFn).toHaveBeenCalledTimes(2));
+    expect(listFn.mock.calls[1][0].org).toBe("globex");
+  });
+});

package/src/search/useResourceCount.ts

@@ -11,7 +11,8 @@ export interface UseResourceCountOptions {
    * Controls resource visibility scope.
    *
    * - `"org"` — all resources owned by the given organization, regardless of visibility.
-   * - `"all"` — all resources the caller is authorized to access, across all organizations.
+   * - `"all"` — all resources owned by the given organization plus public resources
+   *   from other organizations.
    *
    * @default "org"
    */
@@ -64,10 +65,15 @@ export function useResourceCount(
   const { data: count, isLoading, isRefetching, error, refetch } = useFetch<number | undefined>(
     org
       ? async () => {
+          // Identical params to useResourceList so a card's count always matches
+          // the list page it links to. `org` is ALWAYS sent: an empty org means
+          // "every org the caller can access" to the search backend (a global FGA
+          // dump), and `crossOrgPublic` with an empty org matches zero rows.
           const params: ListParams = {
-            org: scope === "all" ? "" : org,
+            org,
             query: query || undefined,
             excludePublic: false,
+            crossOrgPublic: scope === "all",
             page: { num: 1, size: 1 },
           };
           const result = await listFn(params);

package/src/workflow/WorkflowDashboard.tsx

@@ -82,6 +82,7 @@ export const WorkflowDashboard = memo(function WorkflowDashboard({
               create(ListWorkflowExecutionsRequestSchema, {
                 pageSize: 5,
                 phase: ExecutionPhase.EXECUTION_FAILED,
+                org,
               }),
             );
             return [...resp.entries] as readonly WorkflowExecution[];

package/src/workflow/useWorkflowExecutionList.ts

@@ -37,6 +37,16 @@ export interface UseWorkflowExecutionListOptions {
    * When omitted, lists all executions across all workflows.
    */
   readonly workflowId?: string | null;
+  /**
+   * Organization slug to scope the cross-workflow listing to. Applies only
+   * to the `list()` branch (no `workflowId`); ignored by `listByWorkflow()`,
+   * which is already scoped by the workflow itself.
+   *
+   * When omitted, results are bounded only by the caller's view permissions —
+   * for a member of several organizations that spans all of them. Console
+   * pages should always pass the active org.
+   */
+  readonly org?: string | null;
   /**
    * Server-side filter criteria. When set, the backend filters
    * before returning results, reducing transfer size.
@@ -110,6 +120,7 @@ export function useWorkflowExecutionList(
   const pageSize = options?.pageSize ?? 20;
   const pageToken = options?.pageToken ?? "";
   const workflowId = options?.workflowId ?? null;
+  const org = options?.org ?? "";
   const fetchFn = async () => {
     if (workflowId) {
       const resp = await stigmer.workflowExecution.listByWorkflow(
@@ -122,7 +133,7 @@ export function useWorkflowExecutionList(
     }
 
     const resp = await stigmer.workflowExecution.list(
-      create(ListWorkflowExecutionsRequestSchema, { pageSize, pageToken }),
+      create(ListWorkflowExecutionsRequestSchema, { pageSize, pageToken, org }),
     );
     return {
       executions: [...resp.entries],
@@ -138,7 +149,7 @@ export function useWorkflowExecutionList(
     refetch,
   } = useFetch<ExecutionListData>(
     fetchFn,
-    [stigmer, workflowId, pageSize, pageToken],
+    [stigmer, workflowId, org, pageSize, pageToken],
     INITIAL_DATA,
   );