@stigmer/react 3.5.2 → 3.6.0

package/src/index.ts

@@ -770,6 +770,61 @@ export type {
   DatastoreDetailViewProps,
 } from "./datastore/index.js";
 
+// Schedule — the disabled-vs-paused state derivation, the direct-query
+// list core + workbench adapter (schedules are not search-backed), data
+// hooks (get by reference, paginated list, count), behavior hooks
+// (create via apply, resume, trigger once, owner enable/disable via
+// lossless manifest apply), the cadence model (preset ⇄ cron, no cron
+// parsing — recognition of builder-emitted shapes only), the cadence
+// builder, the creation form, and the detail view
+export {
+  deriveScheduleState,
+  formatNextFire,
+  createScheduleListFn,
+  listSchedulesPage,
+  useSchedule,
+  useScheduleList,
+  useScheduleCount,
+  useCreateSchedule,
+  useResumeSchedule,
+  useTriggerSchedule,
+  useSetScheduleEnabled,
+  createScheduleColumns,
+  cadenceToCron,
+  cronToCadence,
+  describeCadence,
+  validateCron,
+  validateTimeZone,
+  WEEKDAY_LABELS,
+  CadenceField,
+  ScheduleForm,
+  ScheduleRowActions,
+  ScheduleDetailView,
+  ScheduleIcon,
+} from "./schedule/index.js";
+export type {
+  ScheduleState,
+  ScheduleStateInfo,
+  ScheduleListClient,
+  SchedulePage,
+  UseScheduleReturn,
+  UseScheduleListOptions,
+  UseScheduleListReturn,
+  UseScheduleCountOptions,
+  UseScheduleCountReturn,
+  UseCreateScheduleReturn,
+  UseResumeScheduleReturn,
+  UseTriggerScheduleReturn,
+  UseSetScheduleEnabledReturn,
+  CadencePreset,
+  CadenceKind,
+  CadenceFieldProps,
+  ScheduleFormProps,
+  ScheduleColumnsOptions,
+  ScheduleRowActionsProps,
+  ScheduleDetailViewProps,
+} from "./schedule/index.js";
+
 // Environment — data hooks, list hook, personal convenience hook, secret reveal, variable management, env var form, system env vars, and styled components
 export {
   useEnvironment,
@@ -1259,13 +1314,18 @@ export {
   useConnectSlackChannel,
   useInstallChannel,
   useChannelToolReadiness,
+  useChannelTemplateReadiness,
   useChannelSessions,
+  useChannelTemplateList,
+  templateStatusPhase,
+  splitTemplateBody,
   AgentChannelsPanel,
   ConnectSlackDialog,
   ConnectWhatsAppDialog,
   ChannelCredentialsDialog,
   ChannelToolCredentials,
   ChannelConversationsDialog,
+  ChannelTemplatesDialog,
 } from "./channel/index.js";
 export type {
   UseAgentChannelListReturn,
@@ -1277,13 +1337,18 @@ export type {
   SlackConnectPhase,
   UseInstallChannelReturn,
   InstallChannelPhase,
+  ChannelTemplateReadiness,
   UseChannelSessionsReturn,
+  UseChannelTemplateListOptions,
+  UseChannelTemplateListReturn,
+  TemplateBodySegment,
   AgentChannelsPanelProps,
   ConnectSlackDialogProps,
   ConnectWhatsAppDialogProps,
   ChannelCredentialsDialogProps,
   ChannelToolCredentialsProps,
   ChannelConversationsDialogProps,
+  ChannelTemplatesDialogProps,
 } from "./channel/index.js";
 
 // Error — structured error display with classification, retry, and contextual guidance

package/src/library/useExportResource.ts

@@ -5,6 +5,7 @@ import { parse as parseYaml } from "yaml";
 import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import type { Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
 import type { Workflow } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
 import { serializeManifest } from "@stigmer/sdk";
 import { toast } from "../feedback/toast.js";
@@ -17,9 +18,9 @@ import { serializeWorkflowYaml } from "../workflow/serialize-workflow-yaml.js";
 /** Options for {@link useExportResource}. */
 export interface UseExportResourceOptions {
   /** The resource kind — determines which serializer is used. */
-  readonly kind: "Agent" | "McpServer" | "Workflow" | "Datastore";
+  readonly kind: "Agent" | "McpServer" | "Workflow" | "Datastore" | "Schedule";
   /** The proto resource to export, or `null` when not yet loaded. */
-  readonly resource: Agent | McpServer | Workflow | Datastore | null;
+  readonly resource: Agent | McpServer | Workflow | Datastore | Schedule | null;
 }
 
 /** Return value of {@link useExportResource}. */
@@ -44,7 +45,7 @@ export interface UseExportResourceReturn {
 
 /**
  * Headless export hook for Stigmer resources (Agent, McpServer,
- * Workflow, Datastore).
+ * Workflow, Datastore, Schedule).
  *
  * Serializes the resource into YAML and JSON formats and provides
  * stable callbacks for copying to clipboard or triggering a file

package/src/organization/OrgProvider.tsx

@@ -12,6 +12,7 @@ import {
 } from "react";
 import type { Organization } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
 import { useStigmer } from "../hooks.js";
+import { useFetchCache } from "../internal/FetchCacheProvider.js";
 
 /** Value exposed by {@link OrgProvider} via {@link useOrg}. */
 export interface OrgContextValue {
@@ -63,19 +64,27 @@ function persistSlug(slug: string): void {
  * organization selection, and persists the choice to `localStorage`
  * under the key `stigmer:activeOrgSlug`.
  *
- * Must be rendered inside a {@link StigmerProvider}.
+ * Must be rendered inside a {@link StigmerProvider}. Mount it BELOW
+ * `FetchCacheProvider` (when one is used): switching the active org clears
+ * the nearest fetch cache, so view state cached under the previous org
+ * context — session and execution entries are keyed by id, not org — can
+ * never bleed into the new one. Navigation on switch stays the host's
+ * responsibility via `OrgSwitcher`'s `onOrgChanged` callback.
  *
  * @example
  * ```tsx
  * <StigmerProvider client={client}>
- *   <OrgProvider>
- *     <App />
- *   </OrgProvider>
+ *   <FetchCacheProvider>
+ *     <OrgProvider>
+ *       <App />
+ *     </OrgProvider>
+ *   </FetchCacheProvider>
  * </StigmerProvider>
  * ```
  */
 export function OrgProvider({ children }: { children: ReactNode }) {
   const stigmer = useStigmer();
+  const fetchCache = useFetchCache();
   const [orgs, setOrgs] = useState<Organization[]>([]);
   const [activeOrg, setActiveOrgState] = useState<Organization | null>(null);
   const [isLoading, setIsLoading] = useState(true);
@@ -140,6 +149,22 @@ export function OrgProvider({ children }: { children: ReactNode }) {
     }
   }, []);
 
+  // Org-switch invariant: view state cached under one org context must not
+  // survive into another. Covers every path that changes the active org
+  // (explicit switch, post-create refresh) while skipping the initial
+  // restore (previous slug is null). Cache keys for sessions/executions are
+  // id-scoped, not org-scoped, so a TTL'd entry would otherwise outlive the
+  // switch. No-op when no FetchCacheProvider is mounted.
+  const previousSlugRef = useRef<string | null>(null);
+  const activeSlug = activeOrg?.metadata?.slug ?? null;
+  useEffect(() => {
+    const previous = previousSlugRef.current;
+    previousSlugRef.current = activeSlug;
+    if (previous !== null && activeSlug !== null && previous !== activeSlug) {
+      fetchCache?.clear();
+    }
+  }, [activeSlug, fetchCache]);
+
   const value = useMemo<OrgContextValue>(
     () => ({
       orgs,

package/src/organization/__tests__/OrgProvider.orgSwitch.test.tsx

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Organization } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
+import { StigmerContext } from "../../context";
+import { FetchCache } from "../../internal/fetch-cache";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { OrgProvider, useOrg } from "../OrgProvider";
+
+const acme = { metadata: { id: "acme", slug: "acme", name: "Acme" } } as Organization;
+const globex = { metadata: { id: "globex", slug: "globex", name: "Globex" } } as Organization;
+
+function createMockStigmer(orgs: Organization[]) {
+  return {
+    organization: {
+      findMyOrganizations: vi.fn().mockResolvedValue({ entries: orgs }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown, cache: FetchCache | null) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        <FetchCacheContext.Provider value={cache}>
+          <OrgProvider>{children}</OrgProvider>
+        </FetchCacheContext.Provider>
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+describe("OrgProvider — org-switch cache invalidation", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("clears the fetch cache when the active org changes", async () => {
+    const cache = new FetchCache();
+    cache.set("session:ses_1", { stale: "from previous org context" });
+
+    const { result } = renderHook(() => useOrg(), {
+      wrapper: wrapper(createMockStigmer([acme, globex]), cache),
+    });
+
+    await waitFor(() => expect(result.current.activeOrg).not.toBeNull());
+
+    // Initial restore must NOT clear — only a genuine change of context does.
+    // Session/execution cache keys are id-scoped (not org-scoped), so without
+    // the clear a switched-away org's view state would survive its 5-min TTL.
+    expect(cache.has("session:ses_1")).toBe(true);
+
+    act(() => result.current.setActiveOrg(globex));
+
+    await waitFor(() => expect(cache.has("session:ses_1")).toBe(false));
+    expect(result.current.activeOrg?.metadata?.slug).toBe("globex");
+  });
+
+  it("does not clear when re-selecting the already-active org", async () => {
+    const cache = new FetchCache();
+
+    const { result } = renderHook(() => useOrg(), {
+      wrapper: wrapper(createMockStigmer([acme, globex]), cache),
+    });
+
+    await waitFor(() => expect(result.current.activeOrg).not.toBeNull());
+    const active = result.current.activeOrg!;
+
+    cache.set("session:ses_1", { fresh: true });
+    act(() => result.current.setActiveOrg(active));
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(cache.has("session:ses_1")).toBe(true);
+  });
+
+  it("works without a FetchCacheProvider (no-op, no crash)", async () => {
+    const { result } = renderHook(() => useOrg(), {
+      wrapper: wrapper(createMockStigmer([acme, globex]), null),
+    });
+
+    await waitFor(() => expect(result.current.activeOrg).not.toBeNull());
+
+    act(() => result.current.setActiveOrg(globex));
+
+    await waitFor(() =>
+      expect(result.current.activeOrg?.metadata?.slug).toBe("globex"),
+    );
+  });
+});

package/src/resource-detail/useDeleteResource.ts

@@ -6,7 +6,12 @@ import { toError } from "../internal/toError.js";
 import { toast } from "../feedback/toast.js";
 
 /** Resource types that support deletion from detail pages. */
-export type DeletableResourceKind = "agent" | "skill" | "mcpServer" | "workflow";
+export type DeletableResourceKind =
+  | "agent"
+  | "skill"
+  | "mcpServer"
+  | "workflow"
+  | "schedule";
 
 export interface UseDeleteResourceReturn {
   /**
@@ -74,6 +79,9 @@ export function useDeleteResource(
         case "workflow":
           await stigmer.workflow.delete(resourceId);
           break;
+        case "schedule":
+          await stigmer.schedule.delete(resourceId);
+          break;
       }
       toast.success(
         resourceName
@@ -106,5 +114,7 @@ function kindLabel(kind: DeletableResourceKind): string {
       return "MCP server";
     case "workflow":
       return "workflow";
+    case "schedule":
+      return "schedule";
   }
 }

package/src/resource-workbench/__tests__/ResourceWorkbench.test.tsx

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, renderHook, screen, waitFor, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { ListResult } from "@stigmer/sdk";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { ResourceWorkbench } from "../components/ResourceWorkbench";
+import { useResourceCollection } from "../hooks/useResourceCollection";
+
+afterEach(cleanup);
+
+function Wrapper({ children }: { children: ReactNode }) {
+  return (
+    <FetchCacheContext.Provider value={null}>
+      {children}
+    </FetchCacheContext.Provider>
+  );
+}
+
+/** A row shaped like a resource proto: the id lives under metadata. */
+interface ProtoLikeRow {
+  readonly metadata: { readonly id: string; readonly slug: string };
+}
+
+function listFnReturning(entries: unknown[], totalCount = entries.length) {
+  return vi.fn(
+    async (): Promise<ListResult> => ({
+      entries: entries as ListResult["entries"],
+      totalCount,
+      totalPages: 1,
+    }),
+  );
+}
+
+describe("ResourceWorkbench searchable prop", () => {
+  it("renders the search input by default", async () => {
+    render(
+      <ResourceWorkbench listFn={listFnReturning([])} org="acme" />,
+      { wrapper: Wrapper },
+    );
+
+    await waitFor(() =>
+      expect(screen.getByRole("textbox", { name: "Search…" })).toBeTruthy(),
+    );
+  });
+
+  it("hides the search input when searchable is false", async () => {
+    render(
+      <ResourceWorkbench
+        listFn={listFnReturning([])}
+        org="acme"
+        searchable={false}
+      />,
+      { wrapper: Wrapper },
+    );
+
+    await waitFor(() => expect(screen.getByText("No resources found")).toBeTruthy());
+    expect(screen.queryByRole("textbox")).toBeNull();
+  });
+});
+
+describe("useResourceCollection row identity", () => {
+  const protoRows: ProtoLikeRow[] = [
+    { metadata: { id: "sch_a", slug: "a" } },
+    { metadata: { id: "sch_b", slug: "b" } },
+  ];
+
+  const columns = [
+    {
+      id: "slug",
+      header: "Slug",
+      cell: (row: ProtoLikeRow) => row.metadata.slug,
+    },
+  ];
+
+  it("uses getItemId for rows without a top-level id", async () => {
+    // Hoisted: a listFn re-created per render would retrigger useFetch.
+    const listFn = listFnReturning(protoRows);
+    const { result } = renderHook(
+      () =>
+        useResourceCollection<ProtoLikeRow>({
+          listFn,
+          org: "acme",
+          columns,
+          getItemId: (row) => row.metadata.id,
+        }),
+      { wrapper: Wrapper },
+    );
+
+    await waitFor(() => expect(result.current.items).toHaveLength(2));
+    const rowIds = result.current.table!.getRowModel().rows.map((r) => r.id);
+    expect(rowIds).toEqual(["sch_a", "sch_b"]);
+  });
+
+  it("falls back to SearchResult.id, then the row index", async () => {
+    const mixed = [{ id: "res_1" }, { name: "no-id" }];
+    const listFn = listFnReturning(mixed);
+    const fallbackColumns = [{ id: "c", header: "C", cell: () => null }];
+    const { result } = renderHook(
+      () =>
+        useResourceCollection({
+          listFn,
+          org: "acme",
+          columns: fallbackColumns,
+        }),
+      { wrapper: Wrapper },
+    );
+
+    await waitFor(() => expect(result.current.items).toHaveLength(2));
+    const rowIds = result.current.table!.getRowModel().rows.map((r) => r.id);
+    expect(rowIds).toEqual(["res_1", "1"]);
+  });
+});

package/src/resource-workbench/components/ResourceWorkbench.tsx

@@ -155,6 +155,15 @@ export interface ResourceWorkbenchProps<TData = SearchResult> {
 
   // --- Layout ------------------------------------------------------------
 
+  /**
+   * Whether the toolbar renders the text-search input. Set `false` for
+   * kinds whose list backend has no text search (e.g. schedules, which
+   * use the direct query instead of the search service) — a search box
+   * that silently matches nothing is worse than none (DD-006). Opt-in
+   * per DD-011: existing consumers keep the search box.
+   * @default true
+   */
+  readonly searchable?: boolean;
   /** Search input placeholder text. @default "Search\u2026" */
   readonly searchPlaceholder?: string;
   /** Accessible label for the workbench region. @default "Resource workbench" */
@@ -228,6 +237,7 @@ export function ResourceWorkbench<TData = SearchResult>({
   emptyAction,
   onRetry,
   headerAction,
+  searchable = true,
   searchPlaceholder = "Search\u2026",
   "aria-label": ariaLabel = "Resource workbench",
   className,
@@ -267,6 +277,7 @@ export function ResourceWorkbench<TData = SearchResult>({
     onSortChange: filtersHook.setSort,
     columns: columns as WorkbenchColumnDef<TData>[],
     enableSelection,
+    getItemId,
     refetchToken,
   });
 
@@ -305,21 +316,27 @@ export function ResourceWorkbench<TData = SearchResult>({
     >
       {/* --- Toolbar: search + filters + view switcher --- */}
       <div className="flex flex-wrap items-center gap-2">
-        <div className="relative flex-1">
-          <SearchIcon className="pointer-events-none absolute left-2.5 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground-subtle" />
-          <input
-            type="text"
-            value={filtersHook.query}
-            onChange={(e) => filtersHook.setQuery(e.target.value)}
-            placeholder={searchPlaceholder}
-            aria-label={searchPlaceholder}
-            className={cn(
-              "w-full rounded-md border border-input bg-background py-1.5 pl-8 pr-3 text-sm",
-              "placeholder:text-muted-foreground-subtle",
-              "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
-            )}
-          />
-        </div>
+        {searchable ? (
+          <div className="relative flex-1">
+            <SearchIcon className="pointer-events-none absolute left-2.5 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground-subtle" />
+            <input
+              type="text"
+              value={filtersHook.query}
+              onChange={(e) => filtersHook.setQuery(e.target.value)}
+              placeholder={searchPlaceholder}
+              aria-label={searchPlaceholder}
+              className={cn(
+                "w-full rounded-md border border-input bg-background py-1.5 pl-8 pr-3 text-sm",
+                "placeholder:text-muted-foreground-subtle",
+                "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+              )}
+            />
+          </div>
+        ) : (
+          // Spacer keeps the scope toggle / view switcher / header action
+          // right-aligned, matching the searchable layout.
+          <div className="flex-1" aria-hidden="true" />
+        )}
         {onScopeChange && (
           <ScopeToggle value={controlledScope} onChange={onScopeChange} />
         )}

package/src/resource-workbench/hooks/useResourceCollection.ts

@@ -57,6 +57,14 @@ export interface UseResourceCollectionOptions<TData = SearchResult> {
   readonly columns?: readonly WorkbenchColumnDef<TData>[];
   /** Enable row selection state tracking. @default false */
   readonly enableSelection?: boolean;
+  /**
+   * Extracts a stable unique ID from an item, used as the TanStack row
+   * id. Provide it whenever the row type does not carry a top-level
+   * `id` (e.g. full resource protos, where the id lives at
+   * `metadata.id`). When omitted, falls back to `SearchResult.id`, then
+   * the row index.
+   */
+  readonly getItemId?: (item: TData) => string;
   /**
    * Opaque token that forces a background refetch whenever its value
    * changes. Use it to re-read the list after an out-of-band mutation
@@ -157,6 +165,7 @@ export function useResourceCollection<TData = SearchResult>(
     onSortChange,
     columns = [],
     enableSelection = false,
+    getItemId,
     refetchToken,
   } = options;
 
@@ -247,7 +256,8 @@ export function useResourceCollection<TData = SearchResult>(
     onRowSelectionChange: enableSelection ? setRowSelection : undefined,
     getCoreRowModel: getCoreRowModel(),
     getSortedRowModel: getSortedRowModel(),
-    getRowId: (row) => (row as SearchResult).id ?? String(items.indexOf(row as TData)),
+    getRowId: (row, index) =>
+      getItemId?.(row) || (row as SearchResult).id || String(index),
     manualPagination: true,
     manualSorting: true,
     enableRowSelection: enableSelection,