@agent-native/dispatch 0.27.19 → 0.28.0

package/src/components/workspace-app-host.tsx

@@ -1,4 +1,5 @@
 import { AgentSidebar } from "@agent-native/core/client/agent-chat";
+import { agentNativePath } from "@agent-native/core/client/api-path";
 import {
   ChatFirstAppPane,
   defaultChatFirstCopy,
@@ -11,9 +12,20 @@ import {
 } from "@agent-native/core/client/hooks";
 import { useT } from "@agent-native/core/client/i18n";
 import { withBuilderUtmTrackingParams } from "@agent-native/core/shared/builder-link-tracking";
-import { IconArrowLeft, IconClockHour4 } from "@tabler/icons-react";
+import {
+  IconAlertTriangle,
+  IconArrowLeft,
+  IconClockHour4,
+} from "@tabler/icons-react";
 import { useTheme } from "next-themes";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
 import { Link } from "react-router";
 
 import { isEmbedSessionExpiredMessage } from "../lib/embed-session-recovery";
@@ -25,7 +37,9 @@ import {
   type WorkspaceAppSummary,
 } from "../lib/workspace-apps";
 import { DISPATCH_WORKSPACE_SSO_FLAG } from "../shared/feature-flags";
+import { workspaceAppChatProxyPath } from "../shared/workspace-app-chat";
 import { ActionQueryError } from "./action-query-error";
+import { Alert, AlertDescription } from "./ui/alert";
 import { Badge } from "./ui/badge";
 import { Button } from "./ui/button";
 import { Skeleton } from "./ui/skeleton";
@@ -67,6 +81,160 @@ export function buildChatFirstEmbedSessionInput(
   return { app: appId, path, chrome: "minimal" };
 }
 
+async function readWorkspaceAppChatProxyError(
+  response: Response,
+): Promise<string> {
+  let body: string;
+  try {
+    body = await response.text();
+  } catch {
+    // coercion-ok: an unreadable body is reported as such, not as an empty error.
+    return `Agent chat proxy returned ${response.status} with an unreadable body.`;
+  }
+  try {
+    const parsed = JSON.parse(body) as { error?: unknown };
+    if (typeof parsed.error === "string" && parsed.error) return parsed.error;
+  } catch {
+    // coercion-ok: a non-JSON body is still reportable as the status line.
+  }
+  return body.trim() || `Agent chat proxy returned ${response.status}.`;
+}
+
+/**
+ * Point the app pane's chat rail at the app's OWN agent through the Dispatch
+ * proxy, and prove the proxy answers before claiming it works. A rail that
+ * quietly fell back to Dispatch's agent would look identical while running the
+ * wrong tools, instructions, and app resources, so a failed probe is a visible
+ * error state instead.
+ */
+function useWorkspaceAppChatApi(appId: string) {
+  const apiUrl = useMemo(
+    () => agentNativePath(workspaceAppChatProxyPath(appId)),
+    [appId],
+  );
+  const [attempt, setAttempt] = useState(0);
+  const [unavailable, setUnavailable] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    setUnavailable(false);
+    // `/mode` is the app's own dev-mode surface: reaching it proves the proxy
+    // minted an app session and the app's agent-chat routes answer.
+    void fetch(`${apiUrl}/mode`, { credentials: "include" })
+      .then(async (response) => {
+        if (response.ok) return;
+        throw new Error(await readWorkspaceAppChatProxyError(response));
+      })
+      .catch((cause: unknown) => {
+        if (cancelled) return;
+        console.warn(
+          `[dispatch] app chat proxy unavailable for ${appId}`,
+          cause,
+        );
+        setUnavailable(true);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [apiUrl, appId, attempt]);
+
+  return {
+    apiUrl,
+    unavailable,
+    retry: useCallback(() => setAttempt((value) => value + 1), []),
+  };
+}
+
+export interface WorkspaceAppChatRailProps {
+  appId: string;
+  appName: string;
+  children: ReactNode;
+  copy?: ChatFirstCopy;
+  agentPageHref?: string;
+  onFullscreenRequest?: () => void;
+}
+
+/**
+ * The chat beside an open workspace app. Every surface that hosts an app pane
+ * must go through here so the rail is always the app's own agent — same tools,
+ * AGENTS.md, skills, app-scoped resources, and dev-mode surface as the app's
+ * native chat — and so an unreachable app is one visible error state rather
+ * than a per-surface silent handoff back to Dispatch's agent.
+ */
+export function WorkspaceAppChatRail({
+  appId,
+  appName,
+  children,
+  copy = defaultChatFirstCopy,
+  agentPageHref,
+  onFullscreenRequest,
+}: WorkspaceAppChatRailProps) {
+  const t = useT();
+  const appChat = useWorkspaceAppChatApi(appId);
+
+  if (appChat.unavailable) {
+    return (
+      <div className="flex h-full min-h-0">
+        <div
+          data-dispatch-app-chat-unavailable
+          className="w-88 shrink-0 overflow-auto border-r p-4"
+        >
+          <Alert variant="destructive">
+            <IconAlertTriangle className="size-4" />
+            <AlertDescription className="flex flex-wrap items-center justify-between gap-3">
+              <span>
+                {t("dispatch.pages.appChatUnavailable", {
+                  defaultValue:
+                    "Dispatch could not connect to {{name}}'s agent, so its chat is unavailable here.",
+                  name: appName,
+                })}
+              </span>
+              <Button
+                type="button"
+                variant="outline"
+                size="sm"
+                onClick={appChat.retry}
+              >
+                {copy("retry")}
+              </Button>
+            </AlertDescription>
+          </Alert>
+        </div>
+        <div className="min-w-0 flex-1">{children}</div>
+      </div>
+    );
+  }
+
+  return (
+    <AgentSidebar
+      position="left"
+      defaultOpen
+      openStorageKey="dispatch-app-chat"
+      storageKey={`dispatch-app-chat:${appId}`}
+      scope={{
+        type: "workspace-app",
+        id: appId,
+        label: appName,
+        contextKey: `workspace-app:${appId}`,
+      }}
+      // The app's own server answers this chat, so its tools, AGENTS.md,
+      // skills, app-scoped resources, and dev-mode surface are the real ones
+      // rather than a copy maintained inside Dispatch.
+      apiUrl={appChat.apiUrl}
+      agentChatSurface="app"
+      showTabBar
+      suppressInlineOpenApp
+      dynamicSuggestions={false}
+      suggestions={[]}
+      emptyStateText={`Ask about ${appName}`}
+      {...(agentPageHref ? { agentPageHref } : {})}
+      {...(onFullscreenRequest ? { onFullscreenRequest } : {})}
+    >
+      {children}
+    </AgentSidebar>
+  );
+}
+
 export interface WorkspaceAppFrameApp {
   id: string;
   name: string;
@@ -250,26 +418,9 @@ export function WorkspaceAppFrame({
   if (!chatSidebar) return appPane;
 
   return (
-    <AgentSidebar
-      position="left"
-      defaultOpen
-      openStorageKey="dispatch-app-chat"
-      storageKey={`dispatch-app-chat:${app.id}`}
-      scope={{
-        type: "workspace-app",
-        id: app.id,
-        label: app.name,
-        contextKey: `workspace-app:${app.id}`,
-      }}
-      agentChatSurface="app"
-      showTabBar
-      suppressInlineOpenApp
-      dynamicSuggestions={false}
-      suggestions={[]}
-      emptyStateText={`Ask about ${app.name}`}
-    >
+    <WorkspaceAppChatRail appId={app.id} appName={app.name} copy={copy}>
       {appPane}
-    </AgentSidebar>
+    </WorkspaceAppChatRail>
   );
 }
 

package/src/hooks/use-navigation-state.spec.ts

@@ -42,6 +42,39 @@ describe("buildDispatchNavigationState", () => {
     });
   });
 
+  it("keeps the embedded app identity on workspace app routes", () => {
+    expect(buildDispatchNavigationState("/apps/mail")).toEqual({
+      view: "workspace-app",
+      path: "/apps/mail",
+      workspaceAppId: "mail",
+      workspaceAppPath: "/",
+    });
+    expect(buildDispatchNavigationState("/apps/mail/inbox")).toEqual({
+      view: "workspace-app",
+      path: "/apps/mail/inbox",
+      workspaceAppId: "mail",
+      workspaceAppPath: "/inbox",
+    });
+  });
+
+  it("still treats the apps index as the list", () => {
+    expect(buildDispatchNavigationState("/apps")).toEqual({
+      view: "apps",
+      path: "/apps",
+    });
+    expect(buildDispatchNavigationState("/apps/")).toEqual({
+      view: "apps",
+      path: "/apps/",
+    });
+  });
+
+  it("reports an undecodable app route as a workspace app with no id", () => {
+    expect(buildDispatchNavigationState("/apps/%E0%A4%A")).toEqual({
+      view: "workspace-app",
+      path: "/apps/%E0%A4%A",
+    });
+  });
+
   it("preserves dreams query context", () => {
     expect(
       buildDispatchNavigationState(

package/src/hooks/use-navigation-state.ts

@@ -16,10 +16,16 @@ import type {
   DispatchExtensionConfig,
   DispatchNavItem,
 } from "../components/index.js";
+import {
+  workspaceAppIdFromRoute,
+  workspaceAppRoute,
+} from "../lib/workspace-apps.js";
 
 export interface NavigationState {
   view: string;
   path?: string;
+  workspaceAppId?: string;
+  workspaceAppPath?: string;
   extensionId?: string;
   extensionSlug?: string;
   dreamId?: string;
@@ -153,6 +159,14 @@ export function buildDispatchNavigationState(
     return state;
   }
 
+  if (state.view === "workspace-app") {
+    const workspaceAppId = workspaceAppIdFromRoute(pathname);
+    if (workspaceAppId) {
+      state.workspaceAppId = workspaceAppId;
+      state.workspaceAppPath = pathname.replace(/^\/apps\/[^/]+/, "") || "/";
+    }
+  }
+
   if (state.view === "dreams") {
     const params = new URLSearchParams(search);
     const dreamId = params.get("dreamId");
@@ -265,6 +279,12 @@ function resolveView(
   }
   if (pathname.startsWith("/browser-chat")) return "browser-chat";
   if (pathname.startsWith("/chat")) return "chat";
+  // A route below /apps/ always embeds one app, so it must not collapse to the
+  // apps list. An id that fails to decode still resolves here without a
+  // `workspaceAppId`, which view-screen reports as an unknown app.
+  if (pathname.startsWith("/apps/") && pathname !== "/apps/") {
+    return "workspace-app";
+  }
   if (pathname.startsWith("/apps")) return "apps";
   if (pathname.startsWith("/operations")) return "operations";
   if (pathname.startsWith("/metrics")) return "metrics";
@@ -291,7 +311,10 @@ function resolveView(
 function resolvePath(
   view?: string,
   extensions?: DispatchExtensionConfig,
-  command?: Pick<NavigationState, "extensionId" | "threadId">,
+  command?: Pick<
+    NavigationState,
+    "extensionId" | "threadId" | "workspaceAppId"
+  >,
 ): string | undefined {
   switch (view) {
     case "admin":
@@ -305,6 +328,10 @@ function resolvePath(
       return "/overview";
     case "apps":
       return "/apps";
+    case "workspace-app":
+      return command?.workspaceAppId
+        ? workspaceAppRoute(command.workspaceAppId)
+        : "/apps";
     case "operations":
     case "monitoring":
     case "observability":

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

@@ -504,31 +504,43 @@ describe("listWorkspaceApps", () => {
         }),
       },
     });
-    expect(mocks.getDbExec).toHaveBeenCalled();
   });
 
-  it("blocks non-admin workspace members from updating app display metadata", async () => {
+  it("lets workspace members update app display metadata", async () => {
     mocks.state.orgRole = "member";
     stubNoPendingContext();
-    stubManifest([{ id: "todo", name: "Todo", path: "/todo" }]);
-
-    await expect(
-      runWithRequestContext(
-        { userEmail: "dev@example.test", orgId: "org-123" },
-        () =>
-          updateWorkspaceAppMetadata({
-            appId: "todo",
-            name: "Todo Board",
-          }),
-      ),
-    ).rejects.toMatchObject({
-      message:
-        "Only organization owners and admins can update app creation settings.",
-      statusCode: 403,
+    stubManifest([
+      {
+        id: "todo",
+        name: "Todo",
+        description: "Original description",
+        path: "/todo",
+      },
+    ]);
+
+    const updated = await runWithRequestContext(
+      { userEmail: "dev@example.test", orgId: "org-123" },
+      () =>
+        updateWorkspaceAppMetadata({
+          appId: "todo",
+          name: "Todo Board",
+          description: "Tracks team work.",
+        }),
+    );
+
+    expect(updated).toMatchObject({
+      name: "Todo Board",
+      description: "Tracks team work.",
+    });
+    expect(mocks.settings.get("workspace-app-metadata:org:org-123")).toEqual({
+      apps: {
+        todo: expect.objectContaining({
+          name: "Todo Board",
+          description: "Tracks team work.",
+          updatedBy: "dev@example.test",
+        }),
+      },
     });
-    expect(
-      mocks.settings.get("workspace-app-metadata:org:org-123"),
-    ).toBeUndefined();
   });
 
   it("generates a concise seed description from an app prompt", () => {

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

@@ -1355,7 +1355,6 @@ export async function updateWorkspaceAppMetadata(input: {
   name?: string | null;
   description?: string | null;
 }): Promise<WorkspaceAppSummary> {
-  await assertCanManageAppCreationSettings();
   const appId = input.appId.trim();
   assertValidWorkspaceAppId(appId);