@nextclaw/ui 0.25.4 → 0.26.0

package/src/features/right-panel-resources/hooks/use-page-resource-actions.ts

@@ -0,0 +1,137 @@
+import { resolveAlternateWorkspaceFileViewer } from "@/features/chat";
+import { readWorkspaceFilePanelView } from "@/features/chat";
+import { useLocation, useNavigate } from "react-router-dom";
+import {
+  usePanelApps,
+  useUpdatePanelAppPreferences,
+} from "@/features/panel-apps";
+import { useAppPresenter } from "@/app/components/app-presenter-provider";
+import { viewportLayoutManager } from "@/app/managers/viewport-layout.manager";
+import { usePageNavigationStore } from "@/features/right-panel-resources/stores/page-navigation.store";
+import {
+  readPanelAppIdFromTab,
+  createChatUiResourceReferenceFromTab,
+} from "@/features/right-panel-resources/utils/right-panel-resource-uri.utils";
+import { pageResourceTab } from "@/features/right-panel-resources/managers/page-resource.manager";
+import type { PageResource } from "@/features/right-panel-resources/types/page-resource.types";
+import type { ContextMenuGroup } from "@/shared/components/ui/context-menu/context-menu";
+import { t } from "@/shared/lib/i18n";
+import { toast } from "sonner";
+
+export function usePageResourceActions() {
+  const app = useAppPresenter();
+  const navigate = useNavigate();
+  const { pathname, search } = useLocation();
+  const pins = usePageNavigationStore((state) => state.pinned);
+  const apps = usePanelApps();
+  const updatePreferences = useUpdatePanelAppPreferences();
+  return (
+    page: PageResource,
+    origin?: "main" | "global" | "workspace",
+  ): ContextMenuGroup[] => {
+    const tab = pageResourceTab(page);
+    const file = readWorkspaceFilePanelView(tab)?.file;
+    const viewer =
+      file?.viewMode === "preview"
+        ? resolveAlternateWorkspaceFileViewer(file.path, file.previewViewer)
+        : null;
+    const appId = readPanelAppIdFromTab(tab);
+    const entry = apps.data?.entries.find(
+      (candidate) => candidate.appId === appId,
+    );
+    const pinned = entry
+      ? entry.mainSidebar
+      : pins.some((item) => item.uri === page.uri);
+    const open = (location: "main" | "sidebar" | "floating") =>
+      app.pageResourceManager.open(page, location, navigate);
+    const items = [
+      {
+        key: "open-main",
+        label: t(page.target.kind === "workspace" ? "workbenchMaximize" : "workbenchOpenMain"),
+        onSelect: () => open("main"),
+      },
+      ...(page.target.kind === "route"
+        ? []
+        : [
+            {
+              key: "open-sidebar",
+              label: t("workbenchDock"),
+              onSelect: () => open("sidebar"),
+            },
+            {
+              key: "open-floating",
+              label: t("workbenchFloatView"),
+              onSelect: () => open("floating"),
+            },
+          ]),
+      {
+        key: "pin-left",
+        pressed: pinned,
+        label: t(pinned ? "pageUnpinLeft" : "pagePinLeft"),
+        disabled: Boolean(entry && updatePreferences.isPending),
+        onSelect: () => {
+          if (entry)
+            updatePreferences.mutate({
+              id: entry.id,
+              preferences: { mainSidebar: !pinned },
+            });
+          else if (pinned) app.pageResourceManager.unpin(page.uri);
+          else app.pageResourceManager.pin(page);
+          if (!pinned)
+            viewportLayoutManager.setMainSidebarAppGroupCollapsed(false);
+        },
+      },
+      ...(createChatUiResourceReferenceFromTab(tab)
+        ? [
+            {
+              key: "add-to-chat",
+              label: t("docBrowserAddToChat"),
+              restoreFocus: false,
+              onSelect: () =>
+                app.pageResourceManager.addToChat(page, pathname, navigate),
+            },
+          ]
+        : []),
+      {
+        key: "copy-uri",
+        label: t("pageCopyUri"),
+        onSelect: () => {
+          void navigator.clipboard
+            .writeText(page.uri)
+            .catch(() => toast.error(t("pageCopyFailed")));
+        },
+      },
+    ];
+    return [
+      { key: "page", items },
+      ...(viewer
+        ? [
+            {
+              key: "file-view",
+              items: [
+                {
+                  key: `viewer:${viewer}`,
+                  label: t(
+                    viewer === "rendered"
+                      ? "chatWorkspaceOpenPreview"
+                      : "chatWorkspaceOpenSource",
+                  ),
+                  onSelect: () =>
+                    app.pageResourceManager.openFileViewer(
+                      page,
+                      viewer,
+                      origin ??
+                        (pathname === "/resource" &&
+                        new URLSearchParams(search).get("uri") === page.uri
+                          ? "main"
+                          : undefined),
+                      navigate,
+                    ),
+                },
+              ],
+            },
+          ]
+        : []),
+    ];
+  };
+}

package/src/features/right-panel-resources/index.ts

@@ -1,12 +1,5 @@
-export { RightPanelResourceHomePage } from '@/features/right-panel-resources/components/right-panel-resource-home-page';
-export { RightPanelResourceRouteResolver } from '@/features/right-panel-resources/utils/right-panel-resource-route-resolver.utils';
-export type {
-  RightPanelResourceHomeNavigationItem,
-  RightPanelResourceKind,
-  RightPanelResourceNavigationTarget,
-  RightPanelResourceTarget,
-} from '@/features/right-panel-resources/types/right-panel-resource.types';
 export {
+  createChatUiResourceReferenceFromTab,
   createPanelAppContentPath,
   createPanelAppResourceUri,
   createPanelAppRightPanelResourceTarget,
@@ -20,3 +13,24 @@ export {
   RIGHT_PANEL_PANEL_APPS_URL,
   RIGHT_PANEL_SERVICE_APPS_URL,
 } from '@/features/right-panel-resources/utils/right-panel-resource-uri.utils';
+export { RightPanelResourceHomePage } from '@/features/right-panel-resources/components/right-panel-resource-home-page';
+export { RightPanelResourceRouteResolver } from '@/features/right-panel-resources/utils/right-panel-resource-route-resolver.utils';
+export type {
+  RightPanelResourceHomeNavigationItem,
+  RightPanelResourceKind,
+  RightPanelResourceNavigationTarget,
+  RightPanelResourceTarget,
+} from '@/features/right-panel-resources/types/right-panel-resource.types';
+
+
+
+export { PageResourceIcon } from './components/page-resource-icon';
+export { PageResourceActionsMenu, PageResourceActionItems } from './components/page-resource-actions-menu';
+export { CurrentPageActions } from './components/current-page-actions';
+export { PageResourceSidebarNav } from './components/page-resource-sidebar-nav';
+export { SYSTEM_OBJECT_RESOURCE_RENDERERS } from './components/system-object-resource';
+export { WORKSPACE_FILE_PANEL_RENDERERS } from './components/workspace-file-resource';
+export { ResourcePage } from './pages/resource-page';
+export { usePageResourceActions } from './hooks/use-page-resource-actions';
+export { PageResourceManager, pageResourceTab } from './managers/page-resource.manager';
+export { pageResourceFromTarget, pageResourceFromTab, pageResourceMainPath, pageResourceFromSystemObject } from './utils/page-resource-identity.utils';

package/src/features/right-panel-resources/managers/__tests__/page-resource.manager.test.ts

@@ -0,0 +1,149 @@
+import type { ChatThreadManager } from "@/features/chat";
+import { useChatThreadStore } from "@/features/chat";
+import { nextclawClient } from "@/shared/lib/api";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { AppPresenter } from "@/app/presenters/app.presenter";
+import { PageResourceManager } from "@/features/right-panel-resources/managers/page-resource.manager";
+import { RightPanelResourceRouteResolver } from "@/features/right-panel-resources/utils/right-panel-resource-route-resolver.utils";
+import { usePageNavigationStore } from "@/features/right-panel-resources/stores/page-navigation.store";
+import { useDocBrowserStore } from "@/shared/components/doc-browser/stores/doc-browser.store";
+import { createDefaultDocBrowserState } from "@/shared/components/doc-browser/utils/doc-browser-state.utils";
+import { pageResourceTab } from "@/features/right-panel-resources/managers/page-resource.manager";
+import {
+  buildSessionPanelUrl,
+  buildSessionPath,
+} from "@/features/chat";
+
+function setup() {
+  const app = {
+    rightPanelResourceRouteResolver: new RightPanelResourceRouteResolver(),
+    docBrowserManager: { openTarget: vi.fn() },
+    workbenchSurfaceManager: {
+      restore: vi.fn(),
+      toggleMaximize: vi.fn(),
+      place: vi.fn(),
+      isVisible: vi.fn(() => false),
+    },
+    chatComposerIntentManager: {
+      requestUiResourceReference: vi.fn(),
+      requestFileReference: vi.fn(),
+      requestSystemObjectReference: vi.fn(),
+    },
+  };
+  return {
+    app,
+    manager: new PageResourceManager(app as unknown as AppPresenter),
+    navigate: vi.fn(),
+  };
+}
+
+describe("shared resource opening policy", () => {
+  beforeEach(() => {
+    usePageNavigationStore.setState({ pinned: [] });
+    useDocBrowserStore.setState({ snapshot: createDefaultDocBrowserState() });
+  });
+  it("opens contextual workspace pages through their owner and maximizes instead of pretending to render a separate main page", () => {
+    const { manager, app, navigate } = setup();
+    const openWorkspacePage = vi.fn(() => useChatThreadStore.getState().setSnapshot({ workspacePanelParentKey: "parent" }));
+    manager.bindWorkspace({ openWorkspacePage } as unknown as ChatThreadManager);
+    const page = manager.resolve("nextclaw://workspace?page=overview&session=parent")!;
+    manager.open(page, "main", navigate);
+    expect(openWorkspacePage).toHaveBeenCalledWith("parent", "overview");
+    expect(app.workbenchSurfaceManager.place).toHaveBeenCalledWith("session-workspace:parent", "docked");
+    expect(app.workbenchSurfaceManager.toggleMaximize).toHaveBeenCalledWith("session-workspace:parent");
+    expect(navigate).toHaveBeenCalledWith(buildSessionPath("parent"));
+  });
+  it("opens an ordinary Panel App URI in the global sidebar by default, preserving explicit main navigation", () => {
+    const { manager, app, navigate } = setup();
+    const page = manager.resolve("nextclaw://panel-app/example-notes")!;
+    expect(page.target.kind).toBe("panel-app");
+    manager.open(page, "default", navigate);
+    expect(navigate).not.toHaveBeenCalled();
+    expect(app.docBrowserManager.openTarget).toHaveBeenCalledWith(page.target, { newTab: true, placement: "docked" });
+    manager.open(page, "main", navigate);
+    expect(navigate).toHaveBeenCalledWith("/apps/panel/example-notes");
+  });
+  it("reuses an already open resource before default main navigation, while an explicit choice overrides it", () => {
+    const { manager, app, navigate } = setup();
+    const page = manager.resolve("nextclaw://panel-app/example-notes")!;
+    useDocBrowserStore.setState({
+      snapshot: {
+        ...createDefaultDocBrowserState(),
+        isOpen: true,
+        tabs: [pageResourceTab(page)],
+      },
+    });
+    manager.open(page, "default", navigate);
+    expect(app.docBrowserManager.openTarget).toHaveBeenCalledWith(page.target, {
+      newTab: true,
+    });
+    expect(navigate).not.toHaveBeenCalled();
+    manager.open(page, "main", navigate);
+    expect(navigate).toHaveBeenCalledWith("/apps/panel/example-notes");
+  });
+  it("reconstructs conversations and pins generic pages without a Panel App identity", () => {
+    const { manager, navigate } = setup();
+    const conversation = manager.resolve(
+      buildSessionPanelUrl("example-session"),
+    )!;
+    manager.open(conversation, "main", navigate);
+    expect(navigate).toHaveBeenCalledWith(buildSessionPath("example-session"));
+    const page = manager.resolve("nextclaw://page?path=%2Fskills")!;
+    manager.pin(page);
+    expect(usePageNavigationStore.getState().pinned[0].uri).toBe(page.uri);
+    manager.unpin(page.uri);
+    expect(usePageNavigationStore.getState().pinned).toEqual([]);
+  });
+  it("uses the same chat reference from resource menus and preserves current conversation context", () => {
+    const { manager, app, navigate } = setup();
+    const page = manager.resolve("nextclaw://panel-app/example-notes")!;
+    manager.addToChat(page, buildSessionPath("example-session"), navigate);
+    expect(
+      app.chatComposerIntentManager.requestUiResourceReference,
+    ).toHaveBeenCalledWith({
+      targetSessionKey: "example-session",
+      reference: expect.objectContaining({ uri: page.uri }),
+    });
+    expect(navigate).not.toHaveBeenCalled();
+  });
+  it("adds resolved object snapshots to chat without sending or substituting a generic UI reference", async () => {
+    const { manager, app, navigate } = setup();
+    const page = manager.resolve("nextclaw://objects/cron-job/existing")!;
+    const reference = {
+      uri: page.uri,
+      objectType: "cron-job",
+      objectId: "existing",
+      assetUri: "ncp://assets/exact-snapshot",
+    };
+    const resolve = vi
+      .spyOn(nextclawClient.systemObjectReferences, "resolve")
+      .mockResolvedValue(reference as never);
+    try {
+      manager.addToChat(page, "/cron", navigate);
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(resolve).toHaveBeenCalledWith(page.uri);
+      expect(
+        app.chatComposerIntentManager.requestSystemObjectReference,
+      ).toHaveBeenCalledWith({ targetSessionKey: null, reference });
+      expect(
+        app.chatComposerIntentManager.requestUiResourceReference,
+      ).not.toHaveBeenCalled();
+      expect(navigate).toHaveBeenCalledWith("/chat");
+    } finally {
+      resolve.mockRestore();
+    }
+  });
+  it("rejects unsafe schemes, unknown internal resources and off-origin route escapes", () => {
+    const { manager } = setup();
+    for (const uri of [
+      "javascript:alert(1)",
+      "data:text/html,x",
+      "nextclaw://missing",
+      "nextclaw://page?path=%2F%2Fevil.test",
+      "nextclaw://page?path=%2Fresource",
+    ]) {
+      expect(manager.resolve(uri)).toBeNull();
+    }
+  });
+});

package/src/features/right-panel-resources/managers/page-resource.manager.ts

@@ -0,0 +1,342 @@
+import { parseSystemObjectReferenceUri } from "@nextclaw/shared";
+import { nextclawClient } from "@/shared/lib/api";
+import { toast } from "sonner";
+import { t } from "@/shared/lib/i18n";
+import { GLOBAL_WORKBENCH_SURFACE } from "@/shared/components/workbench/types/workbench-surface.types";
+import { useChatThreadStore } from "@/features/chat";
+import type { ChatThreadManager } from "@/features/chat";
+import type { AppPresenter } from "@/app/presenters/app.presenter";
+import { useDocBrowserStore } from "@/shared/components/doc-browser/stores/doc-browser.store";
+import { useFloatingSessionStore } from "@/features/chat";
+import { sessionSurfaceManager } from "@/features/chat";
+import {
+  buildSessionPath,
+  parseSessionKeyFromPanelUrl,
+  parseSessionKeyFromRoute,
+} from "@/features/chat";
+import { createChatUiResourceReferenceFromTab } from "@/features/right-panel-resources/utils/right-panel-resource-uri.utils";
+import {
+  pageResourceFromTab,
+  pageResourceFromTarget,
+  pageResourceMainPath,
+} from "@/features/right-panel-resources/utils/page-resource-identity.utils";
+import { usePageNavigationStore } from "@/features/right-panel-resources/stores/page-navigation.store";
+import { createWorkspaceFileViewerTab } from "@/features/chat";
+import {
+  resolveFileResourceTarget,
+  createWorkspaceFilePanelTarget,
+  readWorkspaceFilePanelView,
+} from "@/features/chat";
+import type { DocBrowserTab } from "@/shared/components/doc-browser/types/doc-browser.types";
+import type {
+  PageOpenLocation,
+  PageResource,
+} from "@/features/right-panel-resources/types/page-resource.types";
+
+export function pageResourceTab(page: PageResource): DocBrowserTab {
+  return {
+    ...page.target,
+    id: page.uri,
+    currentUrl: page.target.url,
+    history: [page.target.url],
+    historyIndex: 0,
+    navVersion: 0,
+  };
+}
+
+/** One opening and reference policy shared by menus, navigation entries and links. */
+export class PageResourceManager {
+  private readonly remembered = new Map<string, PageResource>();
+  private workspace?: ChatThreadManager;
+  constructor(private readonly app: AppPresenter) {}
+  bindWorkspace = (owner: ChatThreadManager): void => {
+    this.workspace = owner;
+  };
+
+  remember = (page: PageResource): void => {
+    this.remembered.delete(page.uri);
+    this.remembered.set(page.uri, page);
+    while (this.remembered.size > 100)
+      this.remembered.delete(this.remembered.keys().next().value!);
+  };
+
+  resolve = (
+    uri: string,
+    context?: { workingDir?: string | null; sessionKey?: string | null },
+  ): PageResource | null => {
+    if (!/^(nextclaw:\/\/|https?:\/\/)/i.test(uri)) return null;
+    if (uri.startsWith("nextclaw://file/")) {
+      try {
+        const target = resolveFileResourceTarget(uri, context);
+        return target ? pageResourceFromTarget(target) : null;
+      } catch {
+        return null;
+      }
+    }
+    const saved =
+      this.remembered.get(uri) ??
+      usePageNavigationStore.getState().pinned.find((page) => page.uri === uri);
+    if (saved) return saved;
+    const tab = useDocBrowserStore
+      .getState()
+      .snapshot.tabs.find(
+        (item) => (item.resourceUri ?? item.currentUrl) === uri,
+      );
+    if (tab) return pageResourceFromTab(tab);
+    try {
+      if (uri.startsWith("nextclaw://page?")) {
+        const path = new URL(uri).searchParams.get("path");
+        if (
+          !path?.startsWith("/") ||
+          path.startsWith("//") ||
+          path.startsWith("/resource") ||
+          path.includes("\\")
+        )
+          return null;
+        return {
+          uri,
+          title: path,
+          mainPath: path,
+          target: {
+            kind: "route",
+            title: path,
+            url: path,
+            resourceUri: uri,
+            historyPolicy: "none",
+          },
+        };
+      }
+      if (uri.startsWith("nextclaw://workspace?")) {
+        const params = new URL(uri).searchParams;
+        const kind = params.get("page");
+        if (
+          ![
+            "overview",
+            "child-sessions",
+            "project-files",
+            "cron",
+            "continuous-attention",
+          ].includes(kind ?? "")
+        )
+          return null;
+        return {
+          uri,
+          title: kind!,
+          target: {
+            kind: "workspace",
+            title: kind!,
+            url: uri,
+            resourceUri: uri,
+            historyPolicy: "none",
+          },
+        };
+      }
+      if (uri.startsWith("nextclaw://workspace-file?")) {
+        const params = new URL(uri).searchParams;
+        const file = useChatThreadStore
+          .getState()
+          .snapshot.workspaceFileTabs.find(
+            (item) => item.key === params.get("key"),
+          );
+        if (file)
+          return pageResourceFromTarget(
+            createWorkspaceFilePanelTarget(file, {
+              workingDir: params.get("base") || null,
+              projectRoot: null,
+            }),
+          );
+      }
+      const target = this.app.rightPanelResourceRouteResolver.resolve(uri);
+      if (uri.startsWith("nextclaw://") && target.kind === "content")
+        return null;
+      return pageResourceFromTarget(target);
+    } catch {
+      return null;
+    }
+  };
+
+  pin = (page: PageResource): void => {
+    this.remember(page);
+    usePageNavigationStore.setState(({ pinned }) => ({
+      pinned: [...pinned.filter((item) => item.uri !== page.uri), page].slice(
+        -64,
+      ),
+    }));
+  };
+  unpin = (uri: string): void => {
+    usePageNavigationStore.setState(({ pinned }) => ({
+      pinned: pinned.filter((page) => page.uri !== uri),
+    }));
+  };
+
+  open = (
+    page: PageResource,
+    location: PageOpenLocation,
+    navigate: (path: string) => void,
+  ): void => {
+    this.remember(page);
+    if (page.target.kind === "workspace") {
+      const params = new URL(page.uri).searchParams;
+      const kind = params.get("page") as Parameters<
+        ChatThreadManager["openWorkspacePage"]
+      >[1];
+      const session = params.get("session");
+      navigate(session ? buildSessionPath(session) : "/chat");
+      this.workspace?.openWorkspacePage(session, kind);
+      const parent =
+        useChatThreadStore.getState().snapshot.workspacePanelParentKey;
+      this.app.workbenchSurfaceManager.place(
+        `session-workspace:${parent ?? "draft"}`,
+        location === "floating" ? "floating" : "docked",
+      );
+      if (location === "main")
+        this.app.workbenchSurfaceManager.toggleMaximize(`session-workspace:${parent ?? "draft"}`);
+      return;
+    }
+    const sessionKey = parseSessionKeyFromPanelUrl(page.uri);
+    if (location === "default") {
+      if (
+        sessionKey &&
+        useFloatingSessionStore.getState().session?.sessionKey === sessionKey
+      ) {
+        sessionSurfaceManager.restore();
+        return;
+      }
+      if (this.reuseWorkspace(page, sessionKey)) return;
+      const existing = useDocBrowserStore.getState().snapshot;
+      const tab = existing.tabs.find(
+        (item) => (item.resourceUri ?? item.currentUrl) === page.uri,
+      );
+      if (existing.isOpen && tab) {
+        this.app.docBrowserManager.openTarget(page.target, { newTab: true });
+        this.app.workbenchSurfaceManager.restore(GLOBAL_WORKBENCH_SURFACE);
+        return;
+      }
+    }
+    if (
+      location === "main" ||
+      page.target.kind === "route" ||
+      (location === "default" && page.mainPath && page.target.kind !== "panel-app")
+    ) {
+      navigate(pageResourceMainPath(page));
+    } else if (location === "floating" && sessionKey) {
+      sessionSurfaceManager.open({ sessionKey, title: page.title });
+    } else {
+      this.app.docBrowserManager.openTarget(page.target, {
+        newTab: true,
+        placement: location === "floating" ? "floating" : "docked",
+      });
+    }
+  };
+
+  private reuseWorkspace = (
+    page: PageResource,
+    sessionKey: string | null,
+  ): boolean => {
+    const { snapshot } = useChatThreadStore.getState();
+    const surface = `session-workspace:${snapshot.workspacePanelParentKey ?? "draft"}`;
+    if (
+      !this.workspace ||
+      snapshot.workspacePanelHidden ||
+      !this.app.workbenchSurfaceManager.isVisible(surface)
+    )
+      return false;
+    const file = readWorkspaceFilePanelView(pageResourceTab(page))?.file;
+    if (
+      file &&
+      snapshot.workspaceFileTabs.some((item) => item.key === file.key)
+    )
+      this.workspace.selectWorkspaceFile(file.key);
+    else if (
+      sessionKey &&
+      snapshot.childSessionTabs.some((item) => item.sessionKey === sessionKey)
+    )
+      this.workspace.selectChildSessionDetail(sessionKey);
+    else return false;
+    this.app.workbenchSurfaceManager.restore(surface);
+    return true;
+  };
+
+  openFileViewer = (
+    page: PageResource,
+    viewer: "source" | "rendered",
+    origin: "main" | "global" | "workspace" | undefined,
+    navigate: (path: string) => void,
+  ): void => {
+    const view = readWorkspaceFilePanelView(pageResourceTab(page));
+    if (!view) return;
+    const workspace = useChatThreadStore.getState().snapshot;
+    if (
+      origin !== "main" &&
+      origin !== "global" &&
+      !workspace.workspacePanelHidden &&
+      workspace.workspaceFileTabs.some((file) => file.key === view.file.key) &&
+      this.workspace
+    ) {
+      this.workspace.openWorkspaceFileViewer(view.file.key, viewer);
+      return;
+    }
+    const file = createWorkspaceFileViewerTab(view.file, viewer);
+    if (!file) return;
+    const next = pageResourceFromTarget(
+      createWorkspaceFilePanelTarget(file, view),
+    );
+    this.remember(next);
+    if (origin === "main") {
+      navigate(pageResourceMainPath(next));
+      return;
+    }
+    const tab = useDocBrowserStore
+      .getState()
+      .snapshot.tabs.find((candidate) => candidate.resourceUri === page.uri);
+    if (tab) {
+      this.app.docBrowserManager.setActiveTab(tab.id);
+      this.app.docBrowserManager.openTarget(next.target);
+    } else this.open(next, "default", navigate);
+  };
+
+  addToChat = (
+    page: PageResource,
+    pathname: string,
+    navigate: (path: string) => void,
+  ): void => {
+    const isChat = pathname === "/chat" || pathname.startsWith("/chat/");
+    const targetSessionKey = isChat
+      ? parseSessionKeyFromRoute(pathname.slice("/chat/".length))
+      : null;
+    if (parseSystemObjectReferenceUri(page.uri)) {
+      void nextclawClient.systemObjectReferences
+        .resolve(page.uri)
+        .then((reference) => {
+          this.app.chatComposerIntentManager.requestSystemObjectReference({
+            targetSessionKey,
+            reference,
+          });
+          if (!isChat) navigate("/chat");
+        })
+        .catch(() => toast.error(t("pageUnavailable")));
+      return;
+    }
+    const tab = pageResourceTab(page);
+    const file = readWorkspaceFilePanelView(tab);
+    if (file) {
+      const path =
+        file.file.path.startsWith("/") || !file.workingDir
+          ? file.file.path
+          : `${file.workingDir.replace(/\/$/, "")}/${file.file.path}`;
+      this.app.chatComposerIntentManager.requestFileReference({
+        targetSessionKey,
+        tokenKey: path,
+        label: page.title,
+      });
+    } else {
+      const reference = createChatUiResourceReferenceFromTab(tab);
+      if (!reference) return;
+      this.app.chatComposerIntentManager.requestUiResourceReference({
+        targetSessionKey,
+        reference,
+      });
+    }
+    if (!isChat) navigate("/chat");
+  };
+}