@stigmer/react 3.2.3 → 3.4.0

package/src/manifest/__tests__/useApplyManifest.test.tsx

@@ -0,0 +1,237 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerContext } from "../../context";
+import { useApplyManifest } from "../useApplyManifest";
+
+// The hook runs the real manifest engine (parseManifest from @stigmer/sdk);
+// only the network-facing manifest client is mocked.
+function createMockStigmer(overrides: {
+  apply?: (...args: unknown[]) => Promise<unknown>;
+  getByReference?: (...args: unknown[]) => Promise<unknown>;
+} = {}) {
+  return {
+    manifest: {
+      apply:
+        overrides.apply ??
+        vi.fn().mockImplementation((doc: { handler: { yamlKind: string; displayName: string }; name: string; slug: string; org: string }) =>
+          Promise.resolve({
+            yamlKind: doc.handler.yamlKind,
+            displayName: doc.handler.displayName,
+            name: doc.name,
+            slug: doc.slug,
+            org: doc.org,
+            id: "res_01",
+          }),
+        ),
+      getByReference: overrides.getByReference ?? vi.fn().mockResolvedValue(null),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+const AGENT_YAML = `
+apiVersion: agentic.stigmer.ai/v1
+kind: Agent
+metadata:
+  name: clinic-patient-assistant
+spec:
+  instructions: Short messages.
+`;
+
+const CHANNEL_AND_ENV_YAML = `
+apiVersion: agentic.stigmer.ai/v1
+kind: AgentChannel
+metadata:
+  name: clinic-patient-whatsapp
+  org: rakeshreddi098
+spec:
+  agent_ref:
+    kind: agent
+    org: rakeshreddi098
+    slug: clinic-patient-assistant
+  enabled: true
+---
+apiVersion: agentic.stigmer.ai/v1
+kind: Environment
+metadata:
+  name: clinic-patient-db
+  org: rakeshreddi098
+spec:
+  data:
+    POSTGRES_CONNECTION_URL:
+      value: "***REDACTED***"
+      is_secret: true
+`;
+
+// Validation (parse + existence resolution) debounces across keystrokes.
+const DEBOUNCE_MS = 500;
+
+async function settleValidation() {
+  await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 10);
+}
+
+describe("useApplyManifest", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("validates pasted content and injects the target org", async () => {
+    const { result } = renderHook(() => useApplyManifest("acme"), {
+      wrapper: wrapper(createMockStigmer()),
+    });
+
+    act(() => {
+      result.current.setContent(AGENT_YAML);
+    });
+    expect(result.current.isValidating).toBe(true);
+
+    await act(settleValidation);
+
+    expect(result.current.validationError).toBeNull();
+    expect(result.current.entries).toHaveLength(1);
+    expect(result.current.entries![0]).toMatchObject({
+      action: "create",
+      status: "pending",
+    });
+    expect(result.current.entries![0].document.org).toBe("acme");
+  });
+
+  it("surfaces parse errors with the schema complaint", async () => {
+    const { result } = renderHook(() => useApplyManifest("acme"), {
+      wrapper: wrapper(createMockStigmer()),
+    });
+
+    act(() => {
+      result.current.setContent("kind: Agent\nmetadata:\n  name: x\nspec:\n  bogus_field: 1\n");
+    });
+    await act(settleValidation);
+
+    expect(result.current.entries).toBeNull();
+    expect(result.current.validationError).toContain("Invalid Agent");
+  });
+
+  it("orders multi-document manifests by dependency (Environment before AgentChannel)", async () => {
+    const { result } = renderHook(() => useApplyManifest("rakeshreddi098"), {
+      wrapper: wrapper(createMockStigmer()),
+    });
+
+    act(() => {
+      result.current.setContent(CHANNEL_AND_ENV_YAML);
+    });
+    await act(settleValidation);
+
+    expect(
+      result.current.entries!.map((e) => e.document.handler.yamlKind),
+    ).toEqual(["Environment", "AgentChannel"]);
+    expect(result.current.hasRedactedSecrets).toBe(true);
+  });
+
+  it("marks existing resources as updates in the preview", async () => {
+    const getByReference = vi.fn().mockResolvedValue({ metadata: {} });
+    const { result } = renderHook(() => useApplyManifest("acme"), {
+      wrapper: wrapper(createMockStigmer({ getByReference })),
+    });
+
+    act(() => {
+      result.current.setContent(AGENT_YAML);
+    });
+    await act(settleValidation);
+
+    expect(result.current.entries![0].action).toBe("update");
+  });
+
+  it("applies all documents sequentially and reports success", async () => {
+    const apply = vi.fn().mockImplementation((doc: { handler: { yamlKind: string; displayName: string }; name: string; slug: string; org: string }) =>
+      Promise.resolve({
+        yamlKind: doc.handler.yamlKind,
+        displayName: doc.handler.displayName,
+        name: doc.name,
+        slug: doc.slug,
+        org: doc.org,
+        id: "res_01",
+      }),
+    );
+    const { result } = renderHook(() => useApplyManifest("rakeshreddi098"), {
+      wrapper: wrapper(createMockStigmer({ apply })),
+    });
+
+    act(() => {
+      result.current.setContent(CHANNEL_AND_ENV_YAML);
+    });
+    await act(settleValidation);
+
+    let allApplied = false;
+    await act(async () => {
+      allApplied = await result.current.applyAll();
+    });
+
+    expect(allApplied).toBe(true);
+    expect(apply).toHaveBeenCalledTimes(2);
+    expect(result.current.entries!.map((e) => e.status)).toEqual([
+      "applied",
+      "applied",
+    ]);
+  });
+
+  it("stops at the first failure and marks the rest skipped", async () => {
+    const apply = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("environment rejected"))
+      .mockResolvedValue({});
+    const { result } = renderHook(() => useApplyManifest("rakeshreddi098"), {
+      wrapper: wrapper(createMockStigmer({ apply })),
+    });
+
+    act(() => {
+      result.current.setContent(CHANNEL_AND_ENV_YAML);
+    });
+    await act(settleValidation);
+
+    let allApplied = true;
+    await act(async () => {
+      allApplied = await result.current.applyAll();
+    });
+
+    expect(allApplied).toBe(false);
+    expect(apply).toHaveBeenCalledTimes(1);
+    expect(result.current.entries!.map((e) => e.status)).toEqual([
+      "failed",
+      "skipped",
+    ]);
+    expect(result.current.entries![0].errorMessage).toBe("environment rejected");
+  });
+
+  it("reset clears content, preview, and errors", async () => {
+    const { result } = renderHook(() => useApplyManifest("acme"), {
+      wrapper: wrapper(createMockStigmer()),
+    });
+
+    act(() => {
+      result.current.setContent(AGENT_YAML);
+    });
+    await act(settleValidation);
+    expect(result.current.entries).not.toBeNull();
+
+    act(() => {
+      result.current.reset();
+    });
+
+    expect(result.current.content).toBe("");
+    expect(result.current.entries).toBeNull();
+    expect(result.current.validationError).toBeNull();
+  });
+});

package/src/manifest/__tests__/useEditResourceYaml.test.tsx

@@ -0,0 +1,252 @@
+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 { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { StigmerContext } from "../../context";
+import { useEditResourceYaml } from "../useEditResourceYaml";
+
+// The hooks run the real manifest engine (serializeManifest/parseManifest
+// from @stigmer/sdk); only the network-facing manifest client is mocked.
+function createMockStigmer(overrides: {
+  apply?: (...args: unknown[]) => Promise<unknown>;
+  getByReference?: (...args: unknown[]) => Promise<unknown>;
+} = {}) {
+  return {
+    manifest: {
+      apply:
+        overrides.apply ??
+        vi.fn().mockResolvedValue({
+          yamlKind: "Agent",
+          displayName: "Agent",
+          name: "clinic-patient-assistant",
+          slug: "clinic-patient-assistant",
+          org: "rakeshreddi098",
+          id: "agt_01",
+        }),
+      getByReference:
+        overrides.getByReference ?? vi.fn().mockResolvedValue({ metadata: {} }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+const agent = create(AgentSchema, {
+  metadata: {
+    id: "agt_01",
+    name: "clinic-patient-assistant",
+    slug: "clinic-patient-assistant",
+    org: "rakeshreddi098",
+  },
+  spec: { instructions: "Short messages." },
+});
+
+// The create-vs-update check debounces across keystrokes.
+const DEBOUNCE_MS = 400;
+
+describe("useEditResourceYaml", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("seeds the editor from the serialized resource", () => {
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer()) },
+    );
+
+    expect(result.current.yaml).toContain("kind: Agent");
+    expect(result.current.yaml).toContain("clinic-patient-assistant");
+    expect(result.current.yaml).not.toContain("status:");
+    expect(result.current.isDirty).toBe(false);
+    expect(result.current.validation.status).toBe("valid");
+  });
+
+  it("reports schema violations inline as the user edits", () => {
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer()) },
+    );
+
+    act(() => {
+      result.current.setYaml(
+        result.current.yaml.replace("instructions:", "instrctions:"),
+      );
+    });
+
+    expect(result.current.validation).toMatchObject({
+      status: "invalid",
+      message: expect.stringContaining("Invalid Agent"),
+    });
+  });
+
+  it("rejects a kind change, pointing at the Apply YAML flow instead", () => {
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer()) },
+    );
+
+    act(() => {
+      // A structurally valid Environment — the schema accepts it, so the
+      // kind guard (not the schema) must be what rejects it.
+      result.current.setYaml(
+        [
+          "apiVersion: agentic.stigmer.ai/v1",
+          "kind: Environment",
+          "metadata:",
+          "  name: clinic-patient-db",
+          "  org: rakeshreddi098",
+          "spec:",
+          "  description: not an agent",
+        ].join("\n"),
+      );
+    });
+
+    expect(result.current.validation).toMatchObject({
+      status: "invalid",
+      message: expect.stringContaining("kind changed from Agent to Environment"),
+    });
+  });
+
+  it("resolves the target to 'update' when the reference exists", async () => {
+    const getByReference = vi.fn().mockResolvedValue({ metadata: {} });
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer({ getByReference })) },
+    );
+
+    act(() => {
+      result.current.setYaml(
+        result.current.yaml.replace("Short messages.", "Long messages."),
+      );
+    });
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 10);
+    });
+
+    expect(getByReference).toHaveBeenCalledWith(
+      "Agent",
+      "rakeshreddi098",
+      "clinic-patient-assistant",
+    );
+    expect(result.current.target).toEqual({
+      action: "update",
+      slug: "clinic-patient-assistant",
+    });
+  });
+
+  it("resolves the target to 'create' after a rename (honest preview)", async () => {
+    const getByReference = vi.fn().mockResolvedValue(null);
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer({ getByReference })) },
+    );
+
+    act(() => {
+      // Rename name AND slug — the slug is the apply routing key, so this
+      // is the edit that would land as a brand-new resource.
+      result.current.setYaml(
+        result.current.yaml.replaceAll(
+          "clinic-patient-assistant",
+          "renamed-assistant",
+        ),
+      );
+    });
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 10);
+    });
+
+    expect(getByReference).toHaveBeenCalledWith(
+      "Agent",
+      "rakeshreddi098",
+      "renamed-assistant",
+    );
+    expect(result.current.target).toEqual({
+      action: "create",
+      slug: "renamed-assistant",
+    });
+  });
+
+  it("applies the edited document and clears the dirty flag", async () => {
+    const apply = vi.fn().mockResolvedValue({
+      yamlKind: "Agent",
+      displayName: "Agent",
+      name: "clinic-patient-assistant",
+      slug: "clinic-patient-assistant",
+      org: "rakeshreddi098",
+      id: "agt_01",
+    });
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer({ apply })) },
+    );
+
+    act(() => {
+      result.current.setYaml(
+        result.current.yaml.replace("Short messages.", "Long messages."),
+      );
+    });
+    expect(result.current.isDirty).toBe(true);
+
+    await act(async () => {
+      const applied = await result.current.apply();
+      expect(applied?.slug).toBe("clinic-patient-assistant");
+    });
+
+    expect(apply).toHaveBeenCalledTimes(1);
+    expect(result.current.isDirty).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("surfaces apply failures as error state and re-throws", async () => {
+    const apply = vi.fn().mockRejectedValue(new Error("permission denied"));
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer({ apply })) },
+    );
+
+    act(() => {
+      result.current.setYaml(
+        result.current.yaml.replace("Short messages.", "Long messages."),
+      );
+    });
+
+    await act(async () => {
+      await expect(result.current.apply()).rejects.toThrow("permission denied");
+    });
+
+    expect(result.current.error?.message).toBe("permission denied");
+  });
+
+  it("flags redacted secret markers in the content", () => {
+    const { result } = renderHook(
+      () => useEditResourceYaml({ resource: agent }),
+      { wrapper: wrapper(createMockStigmer()) },
+    );
+
+    expect(result.current.hasRedactedSecrets).toBe(false);
+
+    act(() => {
+      result.current.setYaml(
+        result.current.yaml.replace("Short messages.", "***REDACTED***"),
+      );
+    });
+
+    expect(result.current.hasRedactedSecrets).toBe(true);
+  });
+});

package/src/manifest/index.ts

@@ -0,0 +1,33 @@
+// Manifest domain: the console-facing YAML edit/apply experience for every
+// registry-supported resource kind, built on the @stigmer/sdk manifest
+// engine (parseManifest / serializeManifest / stigmer.manifest).
+//
+// Headless-first (DD-003): the hooks are independently importable; the
+// dialogs compose them with the shared YamlEditor.
+
+export { YamlEditor } from "./YamlEditor.js";
+export type { YamlEditorProps } from "./YamlEditor.js";
+
+export { useEditResourceYaml } from "./useEditResourceYaml.js";
+export type {
+  EditYamlTarget,
+  EditYamlValidation,
+  UseEditResourceYamlOptions,
+  UseEditResourceYamlReturn,
+} from "./useEditResourceYaml.js";
+
+export { useApplyManifest } from "./useApplyManifest.js";
+export type {
+  ManifestEntryStatus,
+  ManifestPreviewEntry,
+  UseApplyManifestReturn,
+} from "./useApplyManifest.js";
+
+export { EditResourceYamlDialog } from "./EditResourceYamlDialog.js";
+export type { EditResourceYamlDialogProps } from "./EditResourceYamlDialog.js";
+
+export { ApplyManifestDialog } from "./ApplyManifestDialog.js";
+export type { ApplyManifestDialogProps } from "./ApplyManifestDialog.js";
+
+export { RedactedSecretsNotice } from "./RedactedSecretsNotice.js";
+export type { RedactedSecretsNoticeProps } from "./RedactedSecretsNotice.js";