@agent-native/dispatch 0.41.1-nightly-20261104110058 → 0.42.0

package/src/routes/pages/chat.spec.tsx

@@ -4,6 +4,7 @@ import { createRoot, type Root } from "react-dom/client";
 import { MemoryRouter } from "react-router";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { TooltipProvider } from "../../components/ui/tooltip";
 import ChatRoute from "./chat";
 
 const clientState = vi.hoisted(() => ({
@@ -57,6 +58,7 @@ vi.mock("@agent-native/toolkit/app/chat/AgentChatHome", () => ({
 
 vi.mock("../../components/create-app-popover", () => ({
   CreateAppPopover: () => null,
+  NewAppButton: () => null,
 }));
 
 vi.mock("@agent-native/core/client/hooks", () => ({
@@ -75,14 +77,15 @@ vi.mock("../../components/layout/Layout", () => ({
   useDispatchWorkspaceAppLauncher: () => ({
     apps: clientState.workspaceApps,
     workspaceApps: clientState.workspaceApps,
-    isLoading: false,
+    workspaceAppsStatus: "ready",
     error: clientState.workspaceAppsError,
     openApp: clientState.openWorkspaceApp,
     retry: clientState.retryWorkspaceApps,
   }),
 }));
 
-vi.mock("../../lib/workspace-app-layout", () => ({
+vi.mock("../../lib/workspace-app-layout", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../lib/workspace-app-layout")>()),
   workspaceAppMatchesQuery: (
     app: { name: string; description?: string },
     query: string,
@@ -150,9 +153,11 @@ describe("Dispatch ChatRoute", () => {
   it("keeps the centered hero layout for a direct new Chat", async () => {
     await act(async () => {
       root.render(
-        <MemoryRouter initialEntries={["/chat"]}>
-          <ChatRoute />
-        </MemoryRouter>,
+        <TooltipProvider>
+          <MemoryRouter initialEntries={["/chat"]}>
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -176,24 +181,26 @@ describe("Dispatch ChatRoute", () => {
   it("opens a Dispatch run with its Agent Teams parent context", async () => {
     await act(async () => {
       root.render(
-        <MemoryRouter
-          initialEntries={[
-            {
-              pathname: "/chat",
-              state: {
-                dispatchThread: {
-                  id: "run-open-1",
-                  threadId: "child-thread",
-                  parentThreadId: "parent-thread",
-                  description: "Review the Slides task",
-                  name: "Slides review",
+        <TooltipProvider>
+          <MemoryRouter
+            initialEntries={[
+              {
+                pathname: "/chat",
+                state: {
+                  dispatchThread: {
+                    id: "run-open-1",
+                    threadId: "child-thread",
+                    parentThreadId: "parent-thread",
+                    description: "Review the Slides task",
+                    name: "Slides review",
+                  },
                 },
               },
-            },
-          ]}
-        >
-          <ChatRoute />
-        </MemoryRouter>,
+            ]}
+          >
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -213,9 +220,11 @@ describe("Dispatch ChatRoute", () => {
   it("renders the colored app directory below the empty chat composer", async () => {
     await act(async () => {
       root.render(
-        <MemoryRouter initialEntries={["/chat"]}>
-          <ChatRoute />
-        </MemoryRouter>,
+        <TooltipProvider>
+          <MemoryRouter initialEntries={["/chat"]}>
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -240,9 +249,11 @@ describe("Dispatch ChatRoute", () => {
 
     await act(async () => {
       root.render(
-        <MemoryRouter initialEntries={["/chat"]}>
-          <ChatRoute />
-        </MemoryRouter>,
+        <TooltipProvider>
+          <MemoryRouter initialEntries={["/chat"]}>
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -263,22 +274,24 @@ describe("Dispatch ChatRoute", () => {
   it("starts bottom-pinned when an Overview prompt is transitioning in", async () => {
     await act(async () => {
       root.render(
-        <MemoryRouter
-          initialEntries={[
-            {
-              pathname: "/chat",
-              state: {
-                dispatchPrompt: {
-                  id: "overview-prompt",
-                  message: "Route this across my apps",
-                  selectedModel: "auto",
+        <TooltipProvider>
+          <MemoryRouter
+            initialEntries={[
+              {
+                pathname: "/chat",
+                state: {
+                  dispatchPrompt: {
+                    id: "overview-prompt",
+                    message: "Route this across my apps",
+                    selectedModel: "auto",
+                  },
                 },
               },
-            },
-          ]}
-        >
-          <ChatRoute />
-        </MemoryRouter>,
+            ]}
+          >
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -320,11 +333,13 @@ describe("Dispatch ChatRoute", () => {
 
     await act(async () => {
       root.render(
-        <MemoryRouter
-          initialEntries={["/chat?agent=agents/research-partner.md"]}
-        >
-          <ChatRoute />
-        </MemoryRouter>,
+        <TooltipProvider>
+          <MemoryRouter
+            initialEntries={["/chat?agent=agents/research-partner.md"]}
+          >
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 
@@ -349,9 +364,11 @@ describe("Dispatch ChatRoute", () => {
   it("keeps threaded chats free of request ID chrome", async () => {
     await act(async () => {
       root.render(
-        <MemoryRouter initialEntries={["/chat/chat-123"]}>
-          <ChatRoute />
-        </MemoryRouter>,
+        <TooltipProvider>
+          <MemoryRouter initialEntries={["/chat/chat-123"]}>
+            <ChatRoute />
+          </MemoryRouter>
+        </TooltipProvider>,
       );
     });
 

package/src/routes/pages/settings-page.tsx

@@ -10,7 +10,11 @@ import {
 import { useT } from "@agent-native/core/client/i18n";
 import { SETTINGS_REDESIGN_FLAG } from "@agent-native/core/feature-flags/registry";
 import { ChangelogSettingsCard } from "@agent-native/toolkit/app/changelog";
-import { OrgMembersPage, TeamPage } from "@agent-native/toolkit/app/org";
+import {
+  OrgAppsPage,
+  OrgMembersPage,
+  TeamPage,
+} from "@agent-native/toolkit/app/org";
 import {
   AccountSettingsCard,
   CORE_SETTINGS_PAGES,
@@ -26,6 +30,7 @@ import { IconShield } from "@tabler/icons-react";
 import { useMemo, useState } from "react";
 import { Link } from "react-router";
 
+import { HostedAppsSettingsGroup } from "../../components/hosted-apps-settings-group";
 import { Button } from "../../components/ui/button";
 import { Switch } from "../../components/ui/switch";
 import { dispatchAccessDescriptor } from "../../shared/app-roles.js";
@@ -38,14 +43,37 @@ if (!coreMembersPage) {
   throw new Error("Core Settings has no members page for Dispatch app roles");
 }
 
+const coreAppsPage = CORE_SETTINGS_PAGES.find((page) => page.id === "apps");
+if (!coreAppsPage) {
+  throw new Error("Core Settings has no apps page for Dispatch hosted apps");
+}
+
 function DispatchMembersSettingsPage() {
   return <OrgMembersPage appRoles={dispatchAccessDescriptor} />;
 }
 
-// The redesigned Settings shows Members from core; Dispatch's replaces it so
-// the app-role column stays.
+function DispatchAppsSettingsPage() {
+  return <OrgAppsPage extraGroups={<HostedAppsSettingsGroup />} />;
+}
+
+// The redesigned Settings shows Members and Apps from core; Dispatch's
+// replace them so the app-role column and the hosted apps group stay.
 registerSettingsPages([
   { ...coreMembersPage, component: DispatchMembersSettingsPage },
+  {
+    ...coreAppsPage,
+    component: DispatchAppsSettingsPage,
+    searchEntries: [
+      ...(coreAppsPage.searchEntries ?? []),
+      {
+        id: "hosted-apps",
+        labelKey: "dispatch.pages.showHostedApps",
+        keywords:
+          "agent-native.com hosted apps built-in agent-native mail calendar hide",
+        anchor: "show-hosted-apps",
+      },
+    ],
+  },
 ]);
 
 export function meta() {

package/src/routes/pages/settings.spec.tsx

@@ -15,6 +15,7 @@ const state = vi.hoisted(() => ({
     searchEntries?: unknown;
   }>,
   membersAppRoles: undefined as unknown,
+  appsExtraGroups: undefined as ReactNode,
   pageProps: null as null | {
     general?: ReactNode;
     generalGroups?: ReactNode;
@@ -61,6 +62,14 @@ vi.mock("@agent-native/toolkit/app/org", () => ({
     state.membersAppRoles = appRoles;
     return <div data-members-page />;
   },
+  OrgAppsPage: ({ extraGroups }: { extraGroups?: ReactNode }) => {
+    state.appsExtraGroups = extraGroups;
+    return <div data-apps-page />;
+  },
+}));
+
+vi.mock("../../components/hosted-apps-settings-group", () => ({
+  HostedAppsSettingsGroup: () => <section data-hosted-apps-group />,
 }));
 
 vi.mock("@agent-native/toolkit/app/settings", () => ({
@@ -72,6 +81,11 @@ vi.mock("@agent-native/toolkit/app/settings", () => ({
       component: () => null,
       searchEntries: [{ id: "invite-members" }],
     },
+    {
+      id: "apps",
+      component: () => null,
+      searchEntries: [{ id: "new-app-privacy" }],
+    },
   ],
   registerSettingsPages: (pages: typeof state.registered) => {
     state.registered.push(...pages);
@@ -145,6 +159,29 @@ describe("Dispatch settings route", () => {
     expect(state.membersAppRoles).toBe(dispatchAccessDescriptor);
   });
 
+  it("replaces core Apps with one that adds the hosted apps group", () => {
+    const apps = state.registered.find((page) => page.id === "apps");
+    expect(apps?.searchEntries).toEqual([
+      { id: "new-app-privacy" },
+      expect.objectContaining({
+        id: "hosted-apps",
+        labelKey: "dispatch.pages.showHostedApps",
+        anchor: "show-hosted-apps",
+      }),
+    ]);
+
+    const Apps = apps!.component;
+    act(() => {
+      root.render(<Apps />);
+    });
+    expect(container.querySelector("[data-apps-page]")).not.toBeNull();
+
+    act(() => {
+      root.render(<>{state.appsExtraGroups}</>);
+    });
+    expect(container.querySelector("[data-hosted-apps-group]")).not.toBeNull();
+  });
+
   it("keeps the language row and Admin link on today's General tab", () => {
     render();
 

package/src/server/lib/app-creation-store.spec.ts

@@ -209,6 +209,20 @@ vi.mock("@agent-native/core/sharing", async (importOriginal) => {
   return {
     ...actual,
     resolveAccess: (...args: any[]) => mocks.resolveAccess(...args),
+    // core's own tests prove resolveAccessMany agrees with resolveAccess, so
+    // this double answers through the same per-app mock the cases configure.
+    resolveAccessMany: async (
+      resourceType: string,
+      resourceIds: string[],
+      ...rest: any[]
+    ) => {
+      const access = new Map<string, unknown>();
+      for (const id of resourceIds) {
+        const resolved = await mocks.resolveAccess(resourceType, id, ...rest);
+        if (resolved) access.set(id, resolved);
+      }
+      return access;
+    },
   };
 });
 

package/src/server/lib/app-creation-store.ts

@@ -11,6 +11,7 @@ import {
 import {
   ActionContractError,
   isActionContractError,
+  noteExternalWrite,
 } from "@agent-native/core/action";
 import { describeErrorWithCauses } from "@agent-native/core/agent/engine/error-detail";
 import { getAppConfig } from "@agent-native/core/app-config";
@@ -55,7 +56,7 @@ import {
   parseAgentProfileMetadata,
   type ConnectRequiredCard,
 } from "@agent-native/core/shared";
-import { resolveAccess } from "@agent-native/core/sharing";
+import { resolveAccessMany } from "@agent-native/core/sharing";
 
 import { getDb } from "../../db/index.js";
 import { workspaceAppRoute } from "../../shared/workspace-app-route.js";
@@ -95,7 +96,6 @@ const WORKSPACE_APPS_ENV_KEY = "AGENT_NATIVE_WORKSPACE_APPS_JSON";
 const WORKSPACE_APPS_MANIFEST_FILE = "workspace-apps.json";
 const WORKSPACE_APPS_GATEWAY_PATH = "/_workspace/apps";
 const WORKSPACE_APPS_GATEWAY_TIMEOUT_MS = 2_500;
-const WORKSPACE_APP_ACCESS_CONCURRENCY = 8;
 const MAX_PENDING_APPS = 50;
 const PENDING_WORKSPACE_APP_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 const AGENT_CARD_PATH = "/.well-known/agent-card.json";
@@ -1889,33 +1889,17 @@ async function filterWorkspaceAppsByAccess(
     candidates.push(app);
   }
 
-  for (
-    let start = 0;
-    start < candidates.length;
-    start += WORKSPACE_APP_ACCESS_CONCURRENCY
-  ) {
-    const batch = candidates.slice(
-      start,
-      start + WORKSPACE_APP_ACCESS_CONCURRENCY,
-    );
-    const decisions = await Promise.all(
-      batch.map(async (app) => {
-        try {
-          const access = await resolveAccess(
-            "workspace-app",
-            app.id,
-            { userEmail, orgId },
-            { skipResourceBody: true },
-          );
-          return { app, allowed: Boolean(access) };
-        } catch (error) {
-          console.warn("[dispatch] workspace app access lookup failed", error);
-          return { app, allowed: false };
-        }
-      }),
-    );
-    for (const decision of decisions) {
-      if (decision.allowed) visibleIds.add(decision.app.id);
+  if (candidates.length > 0) {
+    try {
+      const access = await resolveAccessMany(
+        "workspace-app",
+        candidates.map((app) => app.id),
+        { userEmail, ...(orgId ? { orgId } : {}) },
+        { skipResourceBody: true },
+      );
+      for (const id of access.keys()) visibleIds.add(id);
+    } catch (error) {
+      console.warn("[dispatch] workspace app access lookup failed", error);
     }
   }
 
@@ -2829,6 +2813,7 @@ export async function scaffoldWorkspaceAppFromTemplate(input: {
     });
   } catch (error) {
     if (fs.existsSync(appDir)) {
+      noteExternalWrite("local-disk");
       fs.rmSync(appDir, { recursive: true, force: true });
     }
     throw error;
@@ -2845,6 +2830,7 @@ export async function scaffoldWorkspaceAppFromTemplate(input: {
     });
   } catch (error) {
     if (fs.existsSync(appDir)) {
+      noteExternalWrite("local-disk");
       fs.rmSync(appDir, { recursive: true, force: true });
     }
     throw error;
@@ -2885,6 +2871,7 @@ function runScaffoldCli(input: {
   args: string[];
 }): Promise<string> {
   return new Promise((resolve, reject) => {
+    noteExternalWrite("child-process");
     // pnpm is a pnpm.cmd shim on Windows, which Node starts only through a
     // shell. The app id is validated and the template comes from an allowlist,
     // so one joined command line is safe there.

package/src/server/lib/app-creation-store.write-observation.spec.ts

@@ -0,0 +1,216 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { runWithRequestContext } from "@agent-native/core/server";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { scaffoldWorkspaceAppFromTemplate } from "./app-creation-store.js";
+
+// Scaffolding runs the `agent-native add-app` CLI as a child process, and when
+// it fails the app directory it left behind is removed. Each of those writes
+// reports itself before it runs, so the framework can tell the call wrote.
+const mocks = vi.hoisted(() => ({
+  noteExternalWrite: vi.fn(),
+  spawn: vi.fn(),
+  getSetting: vi.fn(async (_key: string): Promise<unknown> => null),
+  putSetting: vi.fn(async () => {}),
+  mutateSetting: vi.fn(async () => null),
+  getOrgSetting: vi.fn(
+    async (_orgId: string, _key: string): Promise<unknown> => null,
+  ),
+  execute: vi.fn(async () => ({ rows: [] as unknown[], rowsAffected: 0 })),
+}));
+
+vi.mock("@agent-native/core/action", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@agent-native/core/action")>()),
+  noteExternalWrite: mocks.noteExternalWrite,
+}));
+
+vi.mock("node:child_process", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("node:child_process")>()),
+  spawn: (...args: unknown[]) => mocks.spawn(...args),
+}));
+
+vi.mock("@agent-native/core/db", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@agent-native/core/db")>()),
+  getDbExec: () => ({ execute: mocks.execute }),
+}));
+
+vi.mock("@agent-native/core/settings", () => ({
+  getSetting: mocks.getSetting,
+  putSetting: mocks.putSetting,
+  mutateSetting: mocks.mutateSetting,
+  getOrgSetting: mocks.getOrgSetting,
+}));
+
+const ORG_ID = "org-123";
+const METADATA_KEY = "workspace-app-metadata:org:org-123";
+
+const roots: string[] = [];
+const spies: { mockRestore: () => void }[] = [];
+
+class FakeCli extends EventEmitter {
+  readonly stdout = new EventEmitter();
+  readonly stderr = new EventEmitter();
+  readonly kill = vi.fn();
+}
+
+/** The position, within the whole run, of a spy's index-th call. */
+function callOrder(
+  spy: { mock: { invocationCallOrder: number[] } },
+  index = 0,
+): number {
+  const order = spy.mock.invocationCallOrder[index];
+  if (order === undefined) {
+    throw new Error(`Expected call ${index} to be recorded.`);
+  }
+  return order;
+}
+
+/** A workspace root that `findWorkspaceRoot` finds from the process cwd. */
+function workspace(): string {
+  const root = fs.mkdtempSync(
+    path.join(os.tmpdir(), "dispatch-scaffold-observed-"),
+  );
+  roots.push(root);
+  fs.writeFileSync(
+    path.join(root, "package.json"),
+    JSON.stringify({
+      name: "workspace",
+      "agent-native": { workspaceCore: "@agent-native/core" },
+    }),
+  );
+  spies.push(vi.spyOn(process, "cwd").mockReturnValue(root));
+  return root;
+}
+
+function observeRemovals() {
+  const spy = vi.spyOn(fs, "rmSync");
+  spies.push(spy);
+  return spy;
+}
+
+/** Stands in for `pnpm exec agent-native`: runs `beforeExit`, then exits. */
+function fakeCli(input: {
+  code: number;
+  stderr?: string;
+  beforeExit?: () => void;
+}): void {
+  mocks.spawn.mockImplementation(() => {
+    const child = new FakeCli();
+    setImmediate(() => {
+      input.beforeExit?.();
+      if (input.stderr) child.stderr.emit("data", input.stderr);
+      child.emit("exit", input.code);
+    });
+    return child;
+  });
+}
+
+function scaffold() {
+  return runWithRequestContext(
+    { userEmail: "dev@example.test", orgId: ORG_ID },
+    () => scaffoldWorkspaceAppFromTemplate({ template: "mail" }),
+  );
+}
+
+beforeEach(() => {
+  mocks.spawn.mockReset();
+  mocks.spawn.mockImplementation(() => {
+    throw new Error("Unexpected CLI spawn in the scaffold write spec.");
+  });
+  mocks.getSetting.mockReset();
+  mocks.getSetting.mockResolvedValue(null);
+  mocks.getOrgSetting.mockReset();
+  mocks.getOrgSetting.mockResolvedValue(null);
+  mocks.execute.mockReset();
+  mocks.execute.mockResolvedValue({ rows: [], rowsAffected: 0 });
+});
+
+afterEach(() => {
+  for (const spy of spies.splice(0)) spy.mockRestore();
+  for (const root of roots.splice(0)) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  vi.clearAllMocks();
+});
+
+describe("scaffoldWorkspaceAppFromTemplate write observation", () => {
+  it("notes the child-process write before the scaffold CLI spawns", async () => {
+    const root = workspace();
+    fakeCli({ code: 1, stderr: "boom" });
+    const rmSync = observeRemovals();
+
+    await expect(scaffold()).rejects.toThrow("Scaffold failed: boom");
+
+    expect(mocks.spawn).toHaveBeenCalledWith(
+      "pnpm",
+      ["exec", "agent-native", "add-app", "mail", "--template", "mail"],
+      expect.objectContaining({ cwd: root }),
+    );
+    expect(mocks.noteExternalWrite).toHaveBeenCalledTimes(1);
+    expect(mocks.noteExternalWrite).toHaveBeenCalledWith("child-process");
+    expect(callOrder(mocks.noteExternalWrite)).toBeLessThan(
+      callOrder(mocks.spawn),
+    );
+    expect(rmSync).not.toHaveBeenCalled();
+  });
+
+  it("notes the local-disk write before removing a half-made app when the CLI fails", async () => {
+    const root = workspace();
+    const appDir = path.join(root, "apps", "mail");
+    fakeCli({
+      code: 1,
+      stderr: "boom",
+      beforeExit: () => {
+        fs.mkdirSync(appDir, { recursive: true });
+        fs.writeFileSync(path.join(appDir, "package.json"), "{}");
+      },
+    });
+    const rmSync = observeRemovals();
+
+    await expect(scaffold()).rejects.toThrow("Scaffold failed: boom");
+
+    expect(mocks.noteExternalWrite).toHaveBeenNthCalledWith(2, "local-disk");
+    expect(rmSync).toHaveBeenCalledWith(appDir, {
+      recursive: true,
+      force: true,
+    });
+    expect(callOrder(mocks.noteExternalWrite, 1)).toBeLessThan(
+      callOrder(rmSync),
+    );
+    expect(fs.existsSync(appDir)).toBe(false);
+  });
+
+  it("notes the local-disk write before removing the app when its metadata write fails", async () => {
+    const root = workspace();
+    const appDir = path.join(root, "apps", "mail");
+    fakeCli({
+      code: 0,
+      beforeExit: () => {
+        fs.mkdirSync(appDir, { recursive: true });
+      },
+    });
+    mocks.getSetting.mockImplementation(async (key: string) => {
+      if (key === METADATA_KEY) {
+        throw new Error("metadata store unavailable");
+      }
+      return null;
+    });
+    const rmSync = observeRemovals();
+
+    await expect(scaffold()).rejects.toThrow("metadata store unavailable");
+
+    expect(mocks.noteExternalWrite).toHaveBeenNthCalledWith(2, "local-disk");
+    expect(rmSync).toHaveBeenCalledWith(appDir, {
+      recursive: true,
+      force: true,
+    });
+    expect(callOrder(mocks.noteExternalWrite, 1)).toBeLessThan(
+      callOrder(rmSync),
+    );
+    expect(fs.existsSync(appDir)).toBe(false);
+  });
+});