@agent-native/dispatch 0.27.19 → 0.28.0

package/src/actions/view-screen.spec.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
   navigation: {} as Record<string, unknown>,
+  appState: {} as Record<string, unknown>,
   listAgentRunFailures: vi.fn(),
   listThreadDebugSources: vi.fn(),
   listWorkspaceResourceOptions: vi.fn(),
@@ -12,7 +13,9 @@ vi.mock("@agent-native/core", () => ({
 }));
 
 vi.mock("@agent-native/core/application-state", () => ({
-  readAppState: vi.fn(async () => mocks.navigation),
+  readAppState: vi.fn(async (key: string) =>
+    key === "navigation" ? mocks.navigation : (mocks.appState[key] ?? null),
+  ),
 }));
 
 vi.mock("../server/lib/app-creation-store.js", () => ({
@@ -56,6 +59,7 @@ import viewScreen from "./view-screen.js";
 describe("view-screen Thread Debug summary", () => {
   beforeEach(() => {
     mocks.navigation = { view: "thread-debug" };
+    mocks.appState = {};
     mocks.listAgentRunFailures.mockReset();
     mocks.listAgentRunFailures.mockResolvedValue({ failures: [] });
     mocks.listThreadDebugSources.mockReset();
@@ -118,3 +122,91 @@ describe("view-screen Thread Debug summary", () => {
     });
   });
 });
+
+describe("view-screen embedded workspace app", () => {
+  beforeEach(() => {
+    mocks.navigation = { view: "chat" };
+    mocks.appState = {};
+    mocks.listWorkspaceResourceOptions.mockReset();
+    mocks.listWorkspaceResourceOptions.mockResolvedValue([]);
+  });
+
+  it("names the app opened through an /apps/<id> route", async () => {
+    mocks.navigation = {
+      view: "workspace-app",
+      path: "/apps/mail/inbox",
+      workspaceAppId: "mail",
+      workspaceAppPath: "/inbox",
+    };
+
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toEqual({
+      status: "open",
+      id: "mail",
+      path: "/inbox",
+      source: "route",
+    });
+  });
+
+  it("names the chat-first pane app while the route stays on /chat", async () => {
+    mocks.appState["chat-first-pane"] = {
+      appId: "mail",
+      path: "/inbox",
+      placement: "side",
+    };
+
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toEqual({
+      status: "open",
+      id: "mail",
+      path: "/inbox",
+      source: "chat-first-pane",
+    });
+  });
+
+  it("keeps a pane's named screen when it carries no path", async () => {
+    mocks.appState["chat-first-pane"] = { appId: "mail", view: "inbox" };
+
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toEqual({
+      status: "open",
+      id: "mail",
+      path: "/",
+      view: "inbox",
+      source: "chat-first-pane",
+    });
+  });
+
+  it("omits the block when no app is open", async () => {
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toBeUndefined();
+    expect(result.chatSurface).toBeDefined();
+  });
+
+  it("reports an unreadable route app as unknown instead of the apps list", async () => {
+    mocks.navigation = { view: "workspace-app", path: "/apps/%E0%A4%A" };
+
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toMatchObject({
+      status: "unknown",
+      source: "route",
+    });
+    expect(result.embeddedApp.reason).toContain("/apps/%E0%A4%A");
+  });
+
+  it("reports a pane that names no app as unknown, not as no app open", async () => {
+    mocks.appState["chat-first-pane"] = { placement: "side" };
+
+    const result = JSON.parse(await viewScreen.run({}));
+
+    expect(result.embeddedApp).toMatchObject({
+      status: "unknown",
+      source: "chat-first-pane",
+    });
+  });
+});

package/src/actions/view-screen.ts

@@ -32,6 +32,7 @@ import {
   listWorkspaceResourceOptions,
   listWorkspaceResourcesForApp,
 } from "../server/lib/workspace-resources-store.js";
+import { CHAT_FIRST_PANE_STATE_KEY } from "../shared/chat-first-pane.js";
 
 async function runLocalDispatchAction(
   name: string,
@@ -67,9 +68,76 @@ function threadDebugFailureStatus(
     : "all";
 }
 
+/**
+ * The workspace app Dispatch has embedded, or `null` when none is open. A
+ * surface that is showing an app whose identity could not be read reports
+ * `status: "unknown"` — never a plausible-looking id and never silence, so the
+ * agent can tell "no app open" from "an app is open and I cannot name it".
+ */
+type EmbeddedApp =
+  | {
+      status: "open";
+      id: string;
+      /** Path inside the embedded app, not the Dispatch route. */
+      path: string;
+      /** Named screen the pane was opened at, when it carries one instead of a path. */
+      view?: string;
+      source: "route" | "chat-first-pane";
+    }
+  | { status: "unknown"; source: "route" | "chat-first-pane"; reason: string };
+
+async function resolveEmbeddedApp(
+  navigation: Record<string, any> | null,
+): Promise<EmbeddedApp | null> {
+  if (navigation?.view === "workspace-app") {
+    const id =
+      typeof navigation.workspaceAppId === "string"
+        ? navigation.workspaceAppId.trim()
+        : "";
+    if (!id) {
+      return {
+        status: "unknown",
+        source: "route",
+        reason: `The route ${navigation.path ?? "/apps/…"} embeds a workspace app, but its id could not be read from the URL.`,
+      };
+    }
+    return {
+      status: "open",
+      id,
+      path:
+        typeof navigation.workspaceAppPath === "string"
+          ? navigation.workspaceAppPath
+          : "/",
+      source: "route",
+    };
+  }
+
+  // Chat-first mode keeps the route on /chat and opens the app as a surface
+  // tab, so the pane state is the only place the open app is named.
+  if (navigation?.view !== "chat") return null;
+  const pane = await readAppState(CHAT_FIRST_PANE_STATE_KEY);
+  if (pane === null) return null;
+  const appId = typeof pane.appId === "string" ? pane.appId.trim() : "";
+  if (!appId) {
+    return {
+      status: "unknown",
+      source: "chat-first-pane",
+      reason:
+        "A chat-first app pane is recorded, but its stored state does not name an app.",
+    };
+  }
+  return {
+    status: "open",
+    id: appId,
+    path: typeof pane.path === "string" && pane.path ? pane.path : "/",
+    ...(typeof pane.view === "string" && pane.view ? { view: pane.view } : {}),
+    source: "chat-first-pane",
+  };
+}
+
 export default defineAction({
   description:
-    "See what the user is currently looking at in the dispatch UI, including navigation state and a compact operational summary.",
+    "See what the user is currently looking at in the dispatch UI, including navigation state, any embedded workspace app, and a compact operational summary.",
   schema: z.object({}),
   http: false,
   run: async () => {
@@ -84,6 +152,10 @@ export default defineAction({
       approvalPolicy: overview.settings,
     };
     if (navigation) screen.navigation = navigation;
+
+    const embeddedApp = await resolveEmbeddedApp(navigation);
+    if (embeddedApp) screen.embeddedApp = embeddedApp;
+
     if (navigation?.view === "chat" || navigation?.view === "browser-chat") {
       screen.chatSurface = {
         view:
@@ -142,6 +214,7 @@ export default defineAction({
       navigation?.view === "overview" ||
       navigation?.view === "metrics" ||
       navigation?.view === "apps" ||
+      navigation?.view === "workspace-app" ||
       navigation?.view === "new-app"
     ) {
       const workspaceApps = await listWorkspaceApps({

package/src/components/layout/Layout.app-chat.spec.ts

@@ -2,21 +2,30 @@ import { readFileSync } from "node:fs";
 
 import { describe, expect, it } from "vitest";
 
-describe("Dispatch workspace app chat rail", () => {
-  it("owns the iframe chat toggle and persists app-specific threads", () => {
-    const source = readFileSync(
-      new URL("./Layout.tsx", import.meta.url),
-      "utf8",
-    );
+const layoutSource = readFileSync(
+  new URL("./Layout.tsx", import.meta.url),
+  "utf8",
+);
+const railSource = readFileSync(
+  new URL("../workspace-app-host.tsx", import.meta.url),
+  "utf8",
+);
 
-    expect(source).toContain('openStorageKey="dispatch-app-chat"');
-    expect(source).toContain(
-      "storageKey={`dispatch-app-chat:${workspaceAppId}`}",
-    );
-    expect(source).toContain("data-dispatch-workspace-app-frame");
-    expect(source).toContain("chatSidebar");
-    expect(source).toContain(
+describe("Dispatch workspace app chat rail", () => {
+  it("routes the open-app rail through the shared app-chat component", () => {
+    // Both app surfaces must share one rail: a second inlined AgentSidebar is
+    // how one of them silently keeps talking to Dispatch's own agent.
+    expect(layoutSource).toContain("<WorkspaceAppChatRail");
+    expect(layoutSource).toContain("data-dispatch-workspace-app-frame");
+    expect(layoutSource).toContain(
       'window.dispatchEvent(new Event("agent-panel:toggle"))',
     );
+    expect(layoutSource).not.toContain('openStorageKey="dispatch-app-chat"');
+  });
+
+  it("persists app-specific threads and points the rail at the app's own agent", () => {
+    expect(railSource).toContain('openStorageKey="dispatch-app-chat"');
+    expect(railSource).toContain("storageKey={`dispatch-app-chat:${appId}`}");
+    expect(railSource).toContain("apiUrl={appChat.apiUrl}");
   });
 });

package/src/components/layout/Layout.tsx

@@ -112,6 +112,7 @@ import {
   workspaceAppRoute,
   type WorkspaceAppSummary,
 } from "../../lib/workspace-apps";
+import { CHAT_FIRST_PANE_STATE_KEY } from "../../shared/chat-first-pane";
 import { AppIcon } from "../app-icon";
 import { CreateAppPopover } from "../create-app-popover";
 import {
@@ -124,6 +125,7 @@ import { Sheet, SheetContent, SheetDescription, SheetTitle } from "../ui/sheet";
 import { Skeleton } from "../ui/skeleton";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip";
 import {
+  WorkspaceAppChatRail,
   WorkspaceAppFrame,
   WorkspaceAppKeepAlive,
 } from "../workspace-app-host";
@@ -215,7 +217,6 @@ const DISPATCH_SIDEBAR_LABEL = "Dispatch";
 const CHROMELESS_PATHS = ["/approval", "/browser-chat", "/browser-connect"];
 const SIDEBAR_COLLAPSE_KEY = "dispatch.sidebar.collapsed";
 const CHAT_HISTORY_SOURCE_KEY = "dispatch.chat-history.source";
-const CHAT_FIRST_PANE_STATE_KEY = "chat-first-pane";
 
 interface DispatchChatFirstPane {
   appId: string;
@@ -2349,28 +2350,14 @@ export function Layout({
     "Workspace app";
   const workspaceAppContent =
     workspaceAppRouteActive && workspaceAppId ? (
-      <AgentSidebar
-        position="left"
-        defaultOpen
-        openStorageKey="dispatch-app-chat"
-        storageKey={`dispatch-app-chat:${workspaceAppId}`}
-        scope={{
-          type: "workspace-app",
-          id: workspaceAppId,
-          label: workspaceAppChatName,
-          contextKey: `workspace-app:${workspaceAppId}`,
-        }}
-        agentChatSurface="app"
-        showTabBar
-        suppressInlineOpenApp
-        dynamicSuggestions={false}
-        suggestions={[]}
-        emptyStateText={`Ask about ${workspaceAppChatName}`}
+      <WorkspaceAppChatRail
+        appId={workspaceAppId}
+        appName={workspaceAppChatName}
         agentPageHref={agentPageHref}
         onFullscreenRequest={openAskAgentFullscreen}
       >
         <WorkspaceAppKeepAlive activeAppId={workspaceAppId} />
-      </AgentSidebar>
+      </WorkspaceAppChatRail>
     ) : (
       <WorkspaceAppKeepAlive
         activeAppId={workspaceAppRouteActive ? workspaceAppId : null}

package/src/components/workspace-app-chat-rail.spec.tsx

@@ -0,0 +1,182 @@
+// @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";
+
+const railState = vi.hoisted(() => ({
+  sidebarProps: [] as Array<Record<string, unknown>>,
+  fetchImpl: vi.fn(),
+  // Stable identity: the embed effect depends on it, so a fresh mock per
+  // render would re-run the effect forever.
+  mutateAsync: vi.fn().mockResolvedValue({ startUrl: "about:blank" }),
+}));
+
+vi.mock("@agent-native/core/client/agent-chat", () => ({
+  AgentSidebar: (props: Record<string, unknown>) => {
+    railState.sidebarProps.push(props);
+    return (
+      <div data-agent-sidebar data-api-url={String(props.apiUrl ?? "")}>
+        {props.children as React.ReactNode}
+      </div>
+    );
+  },
+}));
+
+vi.mock("@agent-native/core/client/api-path", () => ({
+  agentNativePath: (path: string) => path,
+}));
+
+vi.mock("@agent-native/core/client/chat-first", () => ({
+  ChatFirstAppPane: ({ app }: { app: { name: string } | null }) => (
+    <div data-app-pane>{app?.name}</div>
+  ),
+  defaultChatFirstCopy: (key: string) => key,
+}));
+
+vi.mock("@agent-native/core/client/feature-flags", () => ({
+  useFeatureFlag: () => false,
+}));
+
+vi.mock("@agent-native/core/client/hooks", () => ({
+  useActionMutation: () => ({ mutateAsync: railState.mutateAsync }),
+  useActionQuery: () => ({
+    data: [],
+    isError: false,
+    isLoading: false,
+    refetch: vi.fn(),
+  }),
+}));
+
+vi.mock("@agent-native/core/client/i18n", () => ({
+  useT: () => (key: string, options?: { defaultValue?: string }) =>
+    options?.defaultValue ?? key,
+}));
+
+vi.mock("next-themes", () => ({
+  useTheme: () => ({ resolvedTheme: "light" }),
+}));
+
+import { WorkspaceAppChatRail, WorkspaceAppFrame } from "./workspace-app-host";
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("WorkspaceAppChatRail", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    railState.sidebarProps.length = 0;
+    railState.fetchImpl.mockReset();
+    vi.stubGlobal("fetch", railState.fetchImpl);
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  async function render(node: React.ReactNode) {
+    await act(async () => {
+      root.render(node);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+  }
+
+  it("points the rail at the app's own agent through the Dispatch proxy", async () => {
+    railState.fetchImpl.mockResolvedValue(
+      jsonResponse(200, { devMode: false, canToggle: false }),
+    );
+
+    await render(
+      <WorkspaceAppChatRail appId="mail" appName="Mail">
+        <div data-app-surface />
+      </WorkspaceAppChatRail>,
+    );
+
+    expect(railState.fetchImpl).toHaveBeenCalledWith(
+      "/_agent-native/workspace-app-chat/mail/mode",
+      { credentials: "include" },
+    );
+    const sidebar = container.querySelector("[data-agent-sidebar]");
+    expect(sidebar?.getAttribute("data-api-url")).toBe(
+      "/_agent-native/workspace-app-chat/mail",
+    );
+    expect(container.querySelector("[data-app-surface]")).not.toBeNull();
+  });
+
+  it("shows an error instead of quietly answering from Dispatch's own agent", async () => {
+    railState.fetchImpl.mockResolvedValue(
+      jsonResponse(502, { error: "mail chat is unavailable: no app session" }),
+    );
+
+    await render(
+      <WorkspaceAppChatRail appId="mail" appName="Mail">
+        <div data-app-surface />
+      </WorkspaceAppChatRail>,
+    );
+
+    expect(
+      container.querySelector("[data-dispatch-app-chat-unavailable]"),
+    ).not.toBeNull();
+    // The rail is absent rather than falling back to a Dispatch-scoped chat,
+    // which would run the wrong tools and instructions while looking healthy.
+    expect(container.querySelector("[data-agent-sidebar]")).toBeNull();
+    expect(container.querySelector("[data-app-surface]")).not.toBeNull();
+  });
+
+  it("re-probes the proxy when the error state is retried", async () => {
+    railState.fetchImpl.mockResolvedValueOnce(
+      jsonResponse(502, { error: "temporarily unavailable" }),
+    );
+    railState.fetchImpl.mockResolvedValue(
+      jsonResponse(200, { devMode: false }),
+    );
+
+    await render(
+      <WorkspaceAppChatRail appId="mail" appName="Mail">
+        <div data-app-surface />
+      </WorkspaceAppChatRail>,
+    );
+    const retry = container.querySelector<HTMLButtonElement>(
+      "[data-dispatch-app-chat-unavailable] button",
+    );
+    expect(retry).not.toBeNull();
+
+    await act(async () => {
+      retry?.click();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(railState.fetchImpl).toHaveBeenCalledTimes(2);
+    expect(container.querySelector("[data-agent-sidebar]")).not.toBeNull();
+  });
+
+  it("leaves surfaces with no open app alone — no app rail and no proxy probe", async () => {
+    await render(
+      <WorkspaceAppFrame app={{ id: "mail", name: "Mail", path: "/mail" }} />,
+    );
+
+    expect(container.querySelector("[data-agent-sidebar]")).toBeNull();
+    expect(railState.fetchImpl).not.toHaveBeenCalledWith(
+      expect.stringContaining("workspace-app-chat"),
+      expect.anything(),
+    );
+  });
+});