@agent-native/dispatch 0.14.2 → 0.14.4

package/src/actions/list_apps.ts

@@ -12,17 +12,25 @@ export default defineAction({
   parallelSafe: true,
   run: async () => {
     const apps = await listGrantedDispatchMcpApps();
+    const appSummaries = apps.map((app) => ({
+      id: app.id,
+      name: app.name,
+      description: app.description,
+      url: app.url,
+      running: true,
+      source: "dispatch-mcp-grant",
+    }));
     return {
       workspace: true,
       gateway: "dispatch",
-      apps: apps.map((app) => ({
-        id: app.id,
-        name: app.name,
-        description: app.description,
-        url: app.url,
-        running: true,
-        source: "dispatch-mcp-grant",
-      })),
+      apps: appSummaries,
+      // MCP model-visible results are deliberately text-only unless a tool is
+      // app-only or opens an MCP App. Supplying a compact, valid JSON message
+      // keeps large app catalogs machine-readable instead of letting the
+      // generic text limiter cut the full result into invalid JSON.
+      message: JSON.stringify({
+        apps: appSummaries.map(({ id, name }) => ({ id, name })),
+      }),
     };
   },
 });

package/src/actions/provider-api-register.spec.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for the org-scope authorization added to provider-api-register.
+ *
+ * Plan 014 (advisor-plans/014-custom-registry-scope-authorization.md): this
+ * action previously let ANY authenticated org member upsert/delete an
+ * ORG-scoped custom API provider with no owner/admin check. These tests
+ * assert that org-scope upsert/delete now require the caller to be an org
+ * owner or admin, while user-scope calls and org-scope reads remain
+ * unaffected.
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  getCredentialContext: vi.fn(),
+  execute: vi.fn(),
+  upsertCustomProvider: vi.fn(),
+  deleteCustomProvider: vi.fn(),
+  listCustomProviders: vi.fn(),
+  getCustomProvider: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/server", () => ({
+  getCredentialContext: mocks.getCredentialContext,
+}));
+
+vi.mock("@agent-native/core/db", () => ({
+  getDbExec: () => ({ execute: mocks.execute }),
+}));
+
+// Keep the real `assertCanMutateCustomProviderScope` (it's the guard under
+// test's downstream enforcement point) and only mock the DB-backed CRUD
+// functions, mirroring the `importOriginal` partial-mock pattern used in
+// packages/dispatch/src/server/lib/vault-store.spec.ts.
+vi.mock("@agent-native/core/provider-api", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("@agent-native/core/provider-api")>();
+  return {
+    ...actual,
+    upsertCustomProvider: mocks.upsertCustomProvider,
+    deleteCustomProvider: mocks.deleteCustomProvider,
+    listCustomProviders: mocks.listCustomProviders,
+    getCustomProvider: mocks.getCustomProvider,
+  };
+});
+
+const action = (await import("./provider-api-register.js")).default;
+
+function mockOrgRole(role: string | null): void {
+  mocks.execute.mockResolvedValue({ rows: role ? [{ role }] : [] });
+}
+
+const baseUpsertInput = {
+  operation: "upsert" as const,
+  id: "my-api",
+  label: "My API",
+  baseUrl: "https://api.example.com",
+  auth: { type: "none" as const },
+};
+
+describe("provider-api-register org-scope authorization", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getCredentialContext.mockReturnValue({
+      userEmail: "member@example.com",
+      orgId: "org-a",
+    });
+    mocks.upsertCustomProvider.mockResolvedValue("my-api");
+    mocks.deleteCustomProvider.mockResolvedValue(true);
+  });
+
+  it("rejects an org-scope upsert from a plain member", async () => {
+    mockOrgRole("member");
+
+    await expect(
+      action.run({ ...baseUpsertInput, scope: "org" }),
+    ).rejects.toThrow(/owners and admins/i);
+    expect(mocks.upsertCustomProvider).not.toHaveBeenCalled();
+  });
+
+  it("rejects an org-scope delete from a plain member", async () => {
+    mockOrgRole("member");
+
+    await expect(
+      action.run({ operation: "delete", id: "my-api", scope: "org" }),
+    ).rejects.toThrow(/owners and admins/i);
+    expect(mocks.deleteCustomProvider).not.toHaveBeenCalled();
+  });
+
+  it("rejects an org-scope delete when the caller has no membership row", async () => {
+    mockOrgRole(null);
+
+    await expect(
+      action.run({ operation: "delete", id: "my-api", scope: "org" }),
+    ).rejects.toThrow(/owners and admins/i);
+    expect(mocks.deleteCustomProvider).not.toHaveBeenCalled();
+  });
+
+  it("allows an org-scope upsert from an owner and passes orgRole through", async () => {
+    mockOrgRole("owner");
+
+    await action.run({ ...baseUpsertInput, scope: "org" });
+
+    expect(mocks.upsertCustomProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        scope: "org",
+        scopeId: "org-a",
+        orgRole: "owner",
+      }),
+    );
+  });
+
+  it("allows an org-scope delete from an admin and passes orgRole through", async () => {
+    mockOrgRole("admin");
+
+    await action.run({ operation: "delete", id: "my-api", scope: "org" });
+
+    expect(mocks.deleteCustomProvider).toHaveBeenCalledWith(
+      "org",
+      "org-a",
+      "my-api",
+      "admin",
+    );
+  });
+
+  it("does not require an org role for user-scope upsert/delete", async () => {
+    await action.run({ ...baseUpsertInput, scope: "user" });
+    await action.run({ operation: "delete", id: "my-api", scope: "user" });
+
+    expect(mocks.upsertCustomProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        scope: "user",
+        scopeId: "member@example.com",
+        orgRole: null,
+      }),
+    );
+    expect(mocks.deleteCustomProvider).toHaveBeenCalledWith(
+      "user",
+      "member@example.com",
+      "my-api",
+      null,
+    );
+    // No membership lookup should even happen for user-scope calls.
+    expect(mocks.execute).not.toHaveBeenCalled();
+  });
+
+  it("allows an org-scope upsert/delete when the caller has no active org", async () => {
+    // No org at all — `resolveOrgId` never wired, or a genuinely org-less
+    // solo user. `scopeId` collapses to the caller's own email (same as
+    // scope: "user"), so there's no other org member to protect against;
+    // this must not hard-reject the action's own default scope.
+    mocks.getCredentialContext.mockReturnValue({
+      userEmail: "solo@example.com",
+      orgId: null,
+    });
+
+    await action.run({ ...baseUpsertInput, scope: "org" });
+    await action.run({ operation: "delete", id: "my-api", scope: "org" });
+
+    expect(mocks.upsertCustomProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        scope: "org",
+        scopeId: "solo@example.com",
+        orgRole: "owner",
+      }),
+    );
+    expect(mocks.deleteCustomProvider).toHaveBeenCalledWith(
+      "org",
+      "solo@example.com",
+      "my-api",
+      "owner",
+    );
+    // No org, so no membership lookup should happen either.
+    expect(mocks.execute).not.toHaveBeenCalled();
+  });
+
+  it("does not gate org-scope list/get reads on org role", async () => {
+    mocks.listCustomProviders.mockResolvedValue([]);
+    mocks.getCustomProvider.mockResolvedValue(null);
+
+    await action.run({ operation: "list", scope: "org" });
+    await action.run({ operation: "get", id: "my-api", scope: "org" });
+
+    expect(mocks.listCustomProviders).toHaveBeenCalledWith("org", "org-a");
+    expect(mocks.getCustomProvider).toHaveBeenCalledWith(
+      "org",
+      "org-a",
+      "my-api",
+    );
+    // Reads are intentionally out of scope for the role gate (plan 014).
+    expect(mocks.execute).not.toHaveBeenCalled();
+  });
+});

package/src/actions/provider-api-register.ts

@@ -1,13 +1,50 @@
 import { defineAction } from "@agent-native/core";
+import { getDbExec } from "@agent-native/core/db";
 import {
   upsertCustomProvider,
   deleteCustomProvider,
   listCustomProviders,
   getCustomProvider,
+  assertCanMutateCustomProviderScope,
 } from "@agent-native/core/provider-api";
 import { getCredentialContext } from "@agent-native/core/server";
 import { z } from "zod";
 
+/**
+ * Resolve the caller's role in a specific org, straight from `org_members`.
+ *
+ * `getCredentialContext()` (from `@agent-native/core/server`) only exposes
+ * `{ userEmail, orgId }` — no role. `getOrgContext()` (from
+ * `@agent-native/core/org`) resolves role but requires an `H3Event`, which
+ * `defineAction` handlers are not given. This mirrors the established
+ * no-event role-lookup idiom already used for org-admin gating inside
+ * agent-callable/background code (see `isCurrentUserOrgAdmin` in
+ * `packages/core/src/jobs/tools.ts`, `getViewerOrgRole` in
+ * `packages/dispatch/src/server/lib/usage-metrics-store.ts`, and the same
+ * query in `packages/core/src/mcp/actions/service-token-access.ts`) — same
+ * SQL, same fail-closed-to-null-on-error semantics. Returns null (never an
+ * org role) on any lookup error or when the caller has no membership row in
+ * this org.
+ */
+async function resolveCallerOrgRole(
+  orgId: string | null,
+  email: string,
+): Promise<string | null> {
+  if (!orgId) return null;
+  try {
+    const client = getDbExec();
+    const { rows } = await client.execute({
+      sql: `SELECT role FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
+      args: [orgId, email.toLowerCase()],
+    });
+    if (rows.length === 0) return null;
+    const role = (rows[0] as { role?: unknown }).role;
+    return typeof role === "string" && role ? role : null;
+  } catch {
+    return null;
+  }
+}
+
 const AuthSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("none"),
@@ -138,6 +175,33 @@ After registration the provider appears in provider-api-catalog and can be used
     const scopeId =
       scope === "org" ? (ctx.orgId ?? ctx.userEmail) : ctx.userEmail;
 
+    // Only upsert/delete mutate state; list/get remain readable by any org
+    // member (scoping org-scoped reads is left as a follow-up — see plan
+    // 014). Resolve the caller's role in the *target* org (`scopeId`, which
+    // for scope === "org" is exactly `ctx.orgId`) and enforce owner/admin
+    // before allowing an org-scoped write. `assertCanMutateCustomProviderScope`
+    // is the single source of truth for this check and is also enforced a
+    // second time inside `upsertCustomProvider`/`deleteCustomProvider`
+    // themselves (defense in depth) — calling it here too gives a clear,
+    // early error before any other work happens.
+    //
+    // When the caller has no active org (`ctx.orgId` is null — a solo user,
+    // or an app that hasn't wired `resolveOrgId` at all), `scopeId` above
+    // already collapsed to `ctx.userEmail`: there is no shared org resource
+    // to protect, and no *other* caller can ever address that same scopeId
+    // (every other request's fallback is scoped to *its own* email). Treat
+    // that case like sole ownership of a personal bucket — consistent with
+    // `org/context.ts`'s auto-created personal org, which also assigns the
+    // user role "owner" — rather than hard-rejecting scope: "org" (the
+    // action's own default) for every solo user or org-less app.
+    let orgRole: string | null = null;
+    if ((operation === "upsert" || operation === "delete") && scope === "org") {
+      orgRole = ctx.orgId
+        ? await resolveCallerOrgRole(ctx.orgId, ctx.userEmail)
+        : "owner";
+      assertCanMutateCustomProviderScope(scope, scopeId, orgRole);
+    }
+
     if (operation === "list") {
       const providers = await listCustomProviders(scope, scopeId);
       return {
@@ -165,7 +229,7 @@ After registration the provider appears in provider-api-catalog and can be used
 
     if (operation === "delete") {
       if (!id) throw new Error("id is required for delete operation.");
-      const deleted = await deleteCustomProvider(scope, scopeId, id);
+      const deleted = await deleteCustomProvider(scope, scopeId, id, orgRole);
       return { deleted, id };
     }
 
@@ -186,6 +250,7 @@ After registration the provider appears in provider-api-catalog and can be used
       allowedHostSuffixes,
       defaultHeaders,
       notes,
+      orgRole,
     });
 
     return {

package/src/actions/set-mcp-app-access.spec.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  discoverAgents: vi.fn(),
+  setAccess: vi.fn(),
+  recordAudit: vi.fn(),
+  listAccess: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/server/agent-discovery", () => ({
+  discoverAgents: mocks.discoverAgents,
+}));
+
+vi.mock("../server/lib/mcp-access-store.js", () => ({
+  setDispatchMcpAppAccessSettings: mocks.setAccess,
+}));
+
+vi.mock("../server/lib/dispatch-store.js", () => ({
+  recordAudit: mocks.recordAudit,
+}));
+
+vi.mock("./list-mcp-app-access.js", () => ({
+  default: { run: mocks.listAccess },
+}));
+
+import setMcpAppAccess from "./set-mcp-app-access.js";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.discoverAgents.mockResolvedValue([
+    { id: "analytics" },
+    { id: "slides" },
+  ]);
+  mocks.setAccess.mockResolvedValue(undefined);
+  mocks.recordAudit.mockResolvedValue(undefined);
+  mocks.listAccess.mockResolvedValue({ mode: "selected-apps" });
+});
+
+describe("set-mcp-app-access", () => {
+  it("accepts Dispatch itself in selected-app mode", async () => {
+    await setMcpAppAccess.run({
+      mode: "selected-apps",
+      selectedAppIds: ["Dispatch", "slides"],
+    });
+
+    expect(mocks.setAccess).toHaveBeenCalledWith({
+      mode: "selected-apps",
+      selectedAppIds: ["dispatch", "slides"],
+    });
+  });
+
+  it("allows an owner or admin to revoke every app grant", async () => {
+    await setMcpAppAccess.run({
+      mode: "selected-apps",
+      selectedAppIds: [],
+    });
+
+    expect(mocks.setAccess).toHaveBeenCalledWith({
+      mode: "selected-apps",
+      selectedAppIds: [],
+    });
+  });
+
+  it("rejects unknown app ids before changing access", async () => {
+    await expect(
+      setMcpAppAccess.run({
+        mode: "selected-apps",
+        selectedAppIds: ["unknown"],
+      }),
+    ).rejects.toThrow(/Unknown app/);
+    expect(mocks.setAccess).not.toHaveBeenCalled();
+  });
+});

package/src/actions/set-mcp-app-access.ts

@@ -22,7 +22,7 @@ export default defineAction({
   }),
   run: async (args) => {
     const agents = await discoverAgents("dispatch");
-    const knownIds = new Set(agents.map((agent) => agent.id));
+    const knownIds = new Set(["dispatch", ...agents.map((agent) => agent.id)]);
     const selectedAppIds = Array.from(
       new Set(
         args.selectedAppIds
@@ -36,10 +36,6 @@ export default defineAction({
         `Unknown app(s): ${unknown.join(", ")}. Use list-mcp-app-access to see available app IDs.`,
       );
     }
-    if (args.mode === "selected-apps" && selectedAppIds.length === 0) {
-      throw new Error("selected-apps mode requires at least one app ID.");
-    }
-
     await setDispatchMcpAppAccessSettings({
       mode: args.mode,
       selectedAppIds,

package/src/components/action-query-error.spec.tsx

@@ -0,0 +1,56 @@
+// @vitest-environment happy-dom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ActionQueryError } from "./action-query-error";
+
+vi.mock("@agent-native/core/client", () => ({
+  useT: () => (key: string) =>
+    ({
+      "dispatch.pages.dataLoadFailed": "Couldn't load data",
+      "dispatch.pages.dataLoadFailedDescription":
+        "Dispatch couldn't load this data.",
+      "dispatch.pages.tryAgain": "Try again",
+    })[key] ?? key,
+}));
+
+describe("ActionQueryError", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows a safe query error and retries on request", () => {
+    const onRetry = vi.fn();
+    act(() => {
+      root.render(
+        <ActionQueryError
+          error={new Error("Database unavailable")}
+          onRetry={onRetry}
+        />,
+      );
+    });
+
+    expect(container.textContent).toContain("Couldn't load data");
+    expect(container.textContent).toContain(
+      "Dispatch couldn't load this data.",
+    );
+    expect(container.textContent).not.toContain("Database unavailable");
+    act(() => {
+      container.querySelector("button")?.click();
+    });
+    expect(onRetry).toHaveBeenCalledOnce();
+  });
+});

package/src/components/action-query-error.tsx

@@ -0,0 +1,32 @@
+import { useT } from "@agent-native/core/client";
+import { IconAlertTriangle, IconRefresh } from "@tabler/icons-react";
+
+import { Alert, AlertDescription, AlertTitle } from "./ui/alert";
+import { Button } from "./ui/button";
+
+interface ActionQueryErrorProps {
+  error?: unknown;
+  onRetry: () => unknown;
+  className?: string;
+}
+
+export function ActionQueryError({
+  onRetry,
+  className,
+}: ActionQueryErrorProps) {
+  const t = useT();
+
+  return (
+    <Alert variant="destructive" className={className}>
+      <IconAlertTriangle className="size-4" />
+      <AlertTitle>{t("dispatch.pages.dataLoadFailed")}</AlertTitle>
+      <AlertDescription className="flex flex-wrap items-center justify-between gap-3">
+        <span>{t("dispatch.pages.dataLoadFailedDescription")}</span>
+        <Button type="button" variant="outline" size="sm" onClick={onRetry}>
+          <IconRefresh className="size-4" />
+          {t("dispatch.pages.tryAgain")}
+        </Button>
+      </AlertDescription>
+    </Alert>
+  );
+}

package/src/components/app-keys-popover.spec.tsx

@@ -0,0 +1,85 @@
+// @vitest-environment happy-dom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { AppKeysPanel } from "./app-keys-popover";
+
+const queryState = vi.hoisted(() => ({
+  refetchSecrets: vi.fn(),
+  refetchGrants: vi.fn(),
+  refetchAccess: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/client", () => ({
+  useT: () => (key: string) =>
+    ({
+      "dispatch.pages.dataLoadFailed": "Couldn't load data",
+      "dispatch.pages.dataLoadFailedDescription":
+        "Dispatch couldn't load this data.",
+      "dispatch.pages.tryAgain": "Try again",
+    })[key] ?? key,
+  useActionQuery: (name: string) => {
+    const queries = {
+      "list-vault-secret-options": {
+        data: undefined,
+        isLoading: false,
+        error: new Error("Vault unavailable"),
+        refetch: queryState.refetchSecrets,
+      },
+      "list-vault-grants": {
+        data: [],
+        isLoading: false,
+        error: null,
+        refetch: queryState.refetchGrants,
+      },
+      "get-vault-access-settings": {
+        data: undefined,
+        isLoading: false,
+        error: null,
+        refetch: queryState.refetchAccess,
+      },
+    };
+    return queries[name as keyof typeof queries];
+  },
+  useActionMutation: () => ({ mutate: vi.fn(), isPending: false }),
+}));
+
+describe("AppKeysPanel", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    vi.clearAllMocks();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows a retryable error instead of an empty key list", () => {
+    act(() => {
+      root.render(<AppKeysPanel appId="mail" appName="Mail" />);
+    });
+
+    expect(container.textContent).toContain("Couldn't load data");
+    expect(container.textContent).toContain(
+      "Dispatch couldn't load this data.",
+    );
+    expect(container.textContent).not.toContain("Vault unavailable");
+    expect(container.textContent).not.toContain("No vault keys yet");
+
+    act(() => {
+      container.querySelector("button")?.click();
+    });
+    expect(queryState.refetchSecrets).toHaveBeenCalledOnce();
+    expect(queryState.refetchGrants).toHaveBeenCalledOnce();
+    expect(queryState.refetchAccess).toHaveBeenCalledOnce();
+  });
+});