@stigmer/react 0.4.7 → 0.5.0

package/src/mcp-server/steps/ReviewStep.tsx

@@ -0,0 +1,297 @@
+"use client";
+
+import { useMemo } from "react";
+import { cn } from "@stigmer/theme";
+import { getUserMessage } from "@stigmer/sdk";
+import type { McpServerInput } from "@stigmer/sdk";
+import { serializeMcpServerInputYaml } from "../../library/serialize-resource-yaml";
+import type { McpServerWizardData } from "./types";
+
+/** Props for {@link ReviewStep}. */
+export interface ReviewStepProps {
+  readonly org: string;
+  readonly data: McpServerWizardData;
+  readonly isCreating: boolean;
+  readonly error: Error | null;
+}
+
+/**
+ * Wizard step 3: Review and create.
+ *
+ * Shows a summary card with key configuration details and a full
+ * YAML preview of the MCP server that will be created. The "Create"
+ * action is in the WizardNav footer, not in this component.
+ */
+export function ReviewStep({
+  org,
+  data,
+  isCreating,
+  error,
+}: ReviewStepProps) {
+  const mcpServerInput = useMemo(
+    () => buildMcpServerInput(org, data),
+    [org, data],
+  );
+  const yamlPreview = useMemo(
+    () => serializeMcpServerInputYaml(mcpServerInput),
+    [mcpServerInput],
+  );
+
+  const transportSummary =
+    data.transportType === "http"
+      ? data.httpUrl || "(no URL)"
+      : `${data.stdioCommand}${data.stdioArgs ? ` ${data.stdioArgs}` : ""}` || "(no command)";
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h2 className="text-lg font-semibold text-foreground">
+          Review & Create
+        </h2>
+        <p className="mt-1 text-sm text-muted-foreground">
+          Review the MCP server configuration below, then create it.
+        </p>
+      </div>
+
+      {/* Summary card */}
+      <div className="rounded-lg border border-border p-4">
+        <dl className="grid gap-x-6 gap-y-3 text-sm sm:grid-cols-2">
+          <SummaryItem label="Name" value={data.name} />
+          <SummaryItem label="Slug" value={data.slug} mono />
+          <SummaryItem label="Organization" value={org} mono />
+          <SummaryItem
+            label="Visibility"
+            value={data.visibility === "public" ? "Public" : "Private"}
+          />
+          <SummaryItem
+            label="Transport"
+            value={data.transportType === "http" ? "HTTP" : "Stdio"}
+          />
+          <SummaryItem
+            label={data.transportType === "http" ? "URL" : "Command"}
+            value={transportSummary}
+            mono
+          />
+          {data.description && (
+            <SummaryItem
+              label="Description"
+              value={data.description}
+              className="sm:col-span-2"
+            />
+          )}
+          {data.env.length > 0 && (
+            <SummaryItem
+              label="Env Variables"
+              value={`${data.env.length} declared`}
+            />
+          )}
+          {data.authEnabled && data.authOAuthAppSlug && (
+            <SummaryItem
+              label="OAuth"
+              value={
+                data.authOAuthAppOrg
+                  ? `${data.authOAuthAppOrg}/${data.authOAuthAppSlug}`
+                  : data.authOAuthAppSlug
+              }
+              mono
+            />
+          )}
+        </dl>
+      </div>
+
+      {/* YAML preview */}
+      <div className="space-y-2">
+        <h3 className="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+          YAML Preview
+        </h3>
+        <div className="max-h-80 overflow-auto rounded-lg border border-border bg-muted-faint">
+          <pre className="p-4 font-mono text-xs leading-relaxed text-foreground">
+            {yamlPreview}
+          </pre>
+        </div>
+      </div>
+
+      {/* Error display */}
+      {error && (
+        <div
+          className="rounded-md border border-destructive bg-muted-faint px-4 py-3"
+          role="alert"
+        >
+          <p className="text-sm font-medium text-destructive">
+            Failed to create MCP server
+          </p>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {getUserMessage(error)}
+          </p>
+        </div>
+      )}
+
+      {/* Creating state */}
+      {isCreating && (
+        <p className="text-sm text-muted-foreground" aria-live="polite">
+          Creating MCP server…
+        </p>
+      )}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Summary item
+// ---------------------------------------------------------------------------
+
+function SummaryItem({
+  label,
+  value,
+  mono,
+  className,
+}: {
+  readonly label: string;
+  readonly value: string;
+  readonly mono?: boolean;
+  readonly className?: string;
+}) {
+  return (
+    <div className={className}>
+      <dt className="text-xs text-muted-foreground">{label}</dt>
+      <dd
+        className={cn(
+          "mt-0.5 text-sm text-foreground",
+          mono && "font-mono",
+        )}
+      >
+        {value}
+      </dd>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// buildMcpServerInput
+// ---------------------------------------------------------------------------
+
+/**
+ * Transforms wizard data into the SDK `McpServerInput` shape for submission.
+ * Exported for reuse by `McpServerCreationWizard`.
+ */
+export function buildMcpServerInput(
+  org: string,
+  data: McpServerWizardData,
+): McpServerInput {
+  const input: McpServerInput = {
+    name: data.name.trim(),
+    org,
+    ...(data.slug && { slug: data.slug }),
+    ...(data.description && { description: data.description.trim() }),
+    ...(data.iconUrl && { iconUrl: data.iconUrl.trim() }),
+  };
+
+  if (data.transportType === "http" && data.httpUrl) {
+    const http: McpServerInput["http"] = {
+      url: data.httpUrl.trim(),
+    };
+
+    const headers = buildHeadersMap(data.httpHeaders);
+    if (headers) {
+      http.headers = headers;
+    }
+
+    if (data.httpTimeoutSeconds > 0) {
+      http.timeoutSeconds = data.httpTimeoutSeconds;
+    }
+
+    input.http = http;
+  }
+
+  if (data.transportType === "stdio" && data.stdioCommand) {
+    const stdio: McpServerInput["stdio"] = {
+      command: data.stdioCommand.trim(),
+    };
+
+    const args = parseSpaceSeparated(data.stdioArgs);
+    if (args.length > 0) {
+      stdio.args = args;
+    }
+
+    if (data.stdioWorkingDir.trim()) {
+      stdio.workingDir = data.stdioWorkingDir.trim();
+    }
+
+    input.stdio = stdio;
+  }
+
+  if (data.env.length > 0) {
+    const env: NonNullable<McpServerInput["env"]> = {};
+    for (const entry of data.env) {
+      if (!entry.key) continue;
+      env[entry.key] = {
+        ...(entry.isSecret && { isSecret: true }),
+        ...(entry.description && { description: entry.description }),
+        ...(entry.optional && { optional: true }),
+      };
+    }
+    if (Object.keys(env).length > 0) {
+      input.env = env;
+    }
+  }
+
+  if (data.authEnabled) {
+    const auth: NonNullable<McpServerInput["auth"]> = {};
+
+    if (data.authOAuthAppSlug) {
+      auth.oauthAppRef = {
+        org: data.authOAuthAppOrg,
+        slug: data.authOAuthAppSlug,
+      };
+    }
+    if (data.authTargetEnvVar) {
+      auth.targetEnvVar = data.authTargetEnvVar;
+    }
+    if (data.authTokenLifetimeHint) {
+      auth.tokenLifetimeHint = data.authTokenLifetimeHint;
+    }
+    const scopes = parseCommaSeparated(data.authScopeHints);
+    if (scopes.length > 0) {
+      auth.scopeHints = scopes;
+    }
+    if (data.authDiscoveryUrl) {
+      auth.discoveryUrl = data.authDiscoveryUrl;
+    }
+
+    if (Object.keys(auth).length > 0) {
+      input.auth = auth;
+    }
+  }
+
+  return input;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildHeadersMap(
+  entries: readonly { key: string; value: string }[],
+): Record<string, string> | undefined {
+  const map: Record<string, string> = {};
+  for (const entry of entries) {
+    if (entry.key.trim()) {
+      map[entry.key.trim()] = entry.value;
+    }
+  }
+  return Object.keys(map).length > 0 ? map : undefined;
+}
+
+function parseSpaceSeparated(input: string): string[] {
+  return input
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function parseCommaSeparated(input: string): string[] {
+  return input
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}

package/src/mcp-server/steps/types.ts

@@ -0,0 +1,85 @@
+import type { EnvVarEntry, KeyValueEntry } from "../../resource-creation/types";
+
+export type { EnvVarEntry, KeyValueEntry } from "../../resource-creation/types";
+
+/**
+ * Accumulated form state for the MCP server creation wizard.
+ *
+ * Each field corresponds to a property on `McpServerInput`. The wizard
+ * builds this incrementally across steps, then transforms it into
+ * a `McpServerInput` for submission on the final step.
+ */
+export interface McpServerWizardData {
+  // --- Step 1: Identity & Transport ---
+  /** MCP server display name (required). */
+  readonly name: string;
+  /** URL-friendly slug (auto-derived from name, editable). */
+  readonly slug: string;
+  /** Whether the slug has been manually edited by the user. */
+  readonly slugTouched: boolean;
+  /** Short description (optional). */
+  readonly description: string;
+  /** Icon URL (optional). */
+  readonly iconUrl: string;
+  /** Resource visibility. */
+  readonly visibility: "private" | "public";
+  /** Selected transport type. */
+  readonly transportType: "http" | "stdio";
+  /** HTTP server URL. */
+  readonly httpUrl: string;
+  /** HTTP custom headers. */
+  readonly httpHeaders: KeyValueEntry[];
+  /** HTTP request timeout in seconds (0 = default). */
+  readonly httpTimeoutSeconds: number;
+  /** Stdio command to execute. */
+  readonly stdioCommand: string;
+  /** Stdio command arguments (space-separated string, split on submit). */
+  readonly stdioArgs: string;
+  /** Stdio working directory. */
+  readonly stdioWorkingDir: string;
+
+  // --- Step 2: Environment & Auth ---
+  /** Environment variable declarations. */
+  readonly env: EnvVarEntry[];
+  /** Whether OAuth auth configuration is enabled. */
+  readonly authEnabled: boolean;
+  /** OAuth app reference — organization slug. */
+  readonly authOAuthAppOrg: string;
+  /** OAuth app reference — app slug. */
+  readonly authOAuthAppSlug: string;
+  /** Env var that receives the OAuth token. */
+  readonly authTargetEnvVar: string;
+  /** Token lifetime hint (e.g. "1h", "never"). */
+  readonly authTokenLifetimeHint: string;
+  /** OAuth scope hints (comma-separated, split on submit). */
+  readonly authScopeHints: string;
+  /** OAuth discovery URL. */
+  readonly authDiscoveryUrl: string;
+}
+
+/** Creates the initial empty wizard data. */
+export function createInitialMcpServerWizardData(): McpServerWizardData {
+  return {
+    name: "",
+    slug: "",
+    slugTouched: false,
+    description: "",
+    iconUrl: "",
+    visibility: "private",
+    transportType: "http",
+    httpUrl: "",
+    httpHeaders: [],
+    httpTimeoutSeconds: 0,
+    stdioCommand: "",
+    stdioArgs: "",
+    stdioWorkingDir: "",
+    env: [],
+    authEnabled: false,
+    authOAuthAppOrg: "",
+    authOAuthAppSlug: "",
+    authTargetEnvVar: "",
+    authTokenLifetimeHint: "",
+    authScopeHints: "",
+    authDiscoveryUrl: "",
+  };
+}

package/src/mcp-server/useCreateMcpServer.ts

@@ -0,0 +1,76 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { McpServerInput } from "@stigmer/sdk";
+import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import { useStigmer } from "../hooks";
+import { toError } from "../internal/toError";
+
+/** Return value of {@link useCreateMcpServer}. */
+export interface UseCreateMcpServerReturn {
+  /**
+   * Submit a {@link McpServerInput} to create (or upsert) an MCP server blueprint.
+   *
+   * Uses `stigmer.mcpServer.apply()` — the idempotent upsert operation.
+   * Resolves with the server-created/updated `McpServer` proto including
+   * populated metadata (id, slug, audit timestamps).
+   */
+  readonly create: (input: McpServerInput) => Promise<McpServer>;
+  /** `true` while the apply request is in flight. */
+  readonly isCreating: boolean;
+  /** Error from the last failed create, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that wraps `mcpServer.apply()` with loading and error state.
+ *
+ * Creates an MCP server blueprint from a {@link McpServerInput}. Uses
+ * `apply()` (upsert) rather than `create()` so re-submissions are
+ * idempotent — matching the CLI's `stigmer apply` semantics.
+ *
+ * Follows the established SDK mutation hook pattern: `isCreating` flag,
+ * `error` state, `clearError` reset, result returned from the promise
+ * (not stored in hook state).
+ *
+ * @example
+ * ```tsx
+ * const { create, isCreating, error, clearError } = useCreateMcpServer();
+ *
+ * const server = await create({
+ *   name: "github",
+ *   org: "acme",
+ *   http: { url: "https://mcp.github.com/sse" },
+ *   env: { GITHUB_TOKEN: { isSecret: true, description: "GitHub PAT" } },
+ * });
+ * // server.metadata?.slug → "github"
+ * ```
+ */
+export function useCreateMcpServer(): UseCreateMcpServerReturn {
+  const stigmer = useStigmer();
+  const [isCreating, setIsCreating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const create = useCallback(
+    async (input: McpServerInput): Promise<McpServer> => {
+      setIsCreating(true);
+      setError(null);
+
+      try {
+        return await stigmer.mcpServer.apply(input);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { create, isCreating, error, clearError };
+}

package/src/mcp-server/useUpdateMcpServer.ts

@@ -0,0 +1,55 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import type { McpServerInput } from "@stigmer/sdk";
+import { useStigmer } from "../hooks";
+import { toError } from "../internal/toError";
+
+/** Return value of {@link useUpdateMcpServer}. */
+export interface UseUpdateMcpServerReturn {
+  /** Update an existing MCP server with a full input. Returns the updated resource. */
+  readonly update: (input: McpServerInput) => Promise<McpServer>;
+  /** `true` while the update RPC is in flight. */
+  readonly isUpdating: boolean;
+  /** Error from the last failed update, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Clear the error state. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Mutation hook that updates an existing MCP Server resource.
+ *
+ * Wraps `stigmer.mcpServer.update(input)` with loading and error state.
+ * The caller must provide a **complete** `McpServerInput` — the backend
+ * performs full spec replacement. Use `mcpServerToInput()` to reconstruct
+ * the input from a fetched server, modify the desired field, and pass
+ * the result here.
+ */
+export function useUpdateMcpServer(): UseUpdateMcpServerReturn {
+  const stigmer = useStigmer();
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const update = useCallback(
+    async (input: McpServerInput): Promise<McpServer> => {
+      setIsUpdating(true);
+      setError(null);
+
+      try {
+        return await stigmer.mcpServer.update(input);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsUpdating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { update, isUpdating, error, clearError };
+}

package/src/models/registry.ts

@@ -200,14 +200,22 @@ export function parseRegistryJson(data: unknown): ModelInfo[] {
  *
  * @param apiUrl - Base URL of the Stigmer Cloud API (e.g. `https://api.stigmer.ai`)
  * @param token - Bearer token for authentication (from `client.getAuthCredential()`)
+ * @param customFetch - Optional custom `fetch` implementation. Required in
+ *   Tauri where the global `fetch` is restricted by webview CSP/CORS policies.
+ *   When omitted, the global `fetch` is used.
  * @returns Parsed `ModelInfo[]`.
  */
-export async function fetchModelRegistry(apiUrl: string, token: string | null): Promise<ModelInfo[]> {
+export async function fetchModelRegistry(
+  apiUrl: string,
+  token: string | null,
+  customFetch?: typeof globalThis.fetch,
+): Promise<ModelInfo[]> {
+  const doFetch = customFetch ?? globalThis.fetch;
   const headers: Record<string, string> = {};
   if (token) {
     headers["Authorization"] = `Bearer ${token}`;
   }
-  const res = await fetch(`${apiUrl}/v1/proxy/model-registry`, { headers });
+  const res = await doFetch(`${apiUrl}/v1/proxy/model-registry`, { headers });
   if (!res.ok) throw new Error(`Model registry fetch failed: ${res.status}`);
   const data: unknown = await res.json();
   return parseRegistryJson(data);

package/src/provider.tsx

@@ -173,7 +173,7 @@ function useModelRegistryFetch(client: Stigmer): ModelRegistryState {
 
     const c = clientRef.current;
     c.getAuthCredential()
-      .then((token) => fetchModelRegistry(c.baseUrl, token))
+      .then((token) => fetchModelRegistry(c.baseUrl, token, c.fetch))
       .then((models) => {
         if (!cancelled) {
           setState({ models, isLoading: false, error: null });