feat(desktop): support parent directory navigation and external file paths

apps/desktop/package.json

@@ -174,6 +174,7 @@
 		"node-addon-api": "^7.1.0",
 		"node-pty": "1.1.0",
 		"os-locale": "^6.0.2",
+		"pathe": "^2.0.3",
 		"pidtree": "^0.6.0",
 		"pidusage": "^4.0.1",
 		"posthog-js": "1.310.1",

apps/desktop/src/lib/trpc/routers/filesystem/index.ts

@@ -905,6 +905,60 @@ export const createFilesystemRouter = () => {
 				return { copied, errors };
 			}),
 
+		/**
+		 * Read a file by absolute path with size cap and binary detection.
+		 * Used for viewing files outside the current worktree.
+		 */
+		readFile: publicProcedure
+			.input(
+				z.object({
+					filePath: z.string(),
+				}),
+			)
+			.query(
+				async ({
+					input,
+				}): Promise<
+					| {
+							ok: true;
+							content: string;
+							truncated: boolean;
+							byteLength: number;
+					  }
+					| {
+							ok: false;
+							reason: "not-found" | "too-large" | "binary";
+					  }
+				> => {
+					const MAX_FILE_SIZE = 2 * 1024 * 1024;
+					try {
+						const stats = await fs.stat(input.filePath);
+						if (stats.size > MAX_FILE_SIZE) {
+							return { ok: false, reason: "too-large" };
+						}
+
+						const buffer = await fs.readFile(input.filePath);
+
+						// Binary detection (same as readWorkingFile)
+						const checkLength = Math.min(buffer.length, BINARY_CHECK_SIZE);
+						for (let i = 0; i < checkLength; i++) {
+							if (buffer[i] === 0) {
+								return { ok: false, reason: "binary" };
+							}
+						}
+
+						return {
+							ok: true,
+							content: buffer.toString("utf-8"),
+							truncated: false,
+							byteLength: buffer.length,
+						};
+					} catch {
+						return { ok: false, reason: "not-found" };
+					}
+				},
+			),
+
 		exists: publicProcedure
 			.input(z.object({ path: z.string() }))
 			.query(async ({ input }) => {

apps/desktop/src/renderer/screens/main/components/CommandPalette/CommandPalette.tsx

@@ -62,7 +62,7 @@ export function CommandPalette({
 			isLoading={isLoading}
 			results={searchResults}
 			getItemValue={(file) => `${file.path} ${query}`}
-			onSelectItem={(file) => onSelectFile(file.relativePath)}
+			onSelectItem={(file) => onSelectFile(file.path)}
 			renderItem={(file) => {
 				const { icon: Icon, color } = getFileIcon(file.name, false);
 				return (

apps/desktop/src/renderer/screens/main/components/KeywordSearch/useKeywordSearch.ts

@@ -85,7 +85,7 @@ export function useKeywordSearch({
 	const selectMatch = useCallback(
 		(match: KeywordSearchResult) => {
 			useTabsStore.getState().addFileViewerPane(workspaceId, {
-				filePath: match.relativePath,
+				filePath: match.path,
 				line: match.line,
 				column: match.column,
 			});

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatMastraPane/ChatMastraInterface/components/ChatMastraMessageList/components/UserMessage/UserMessage.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useState } from "react";
 import { useTabsStore } from "renderer/stores/tabs/store";
+import { resolveToAbsolutePath } from "../../../../../../ChatPane/ChatInterface/utils/file-paths";
 import type {
 	UserMessageActionPayload,
 	UserMessageRestartRequest,
@@ -58,9 +59,17 @@ export function UserMessage({
 	);
 	const openMentionedFile = useCallback(
 		(filePath: string) => {
-			addFileViewerPane(workspaceId, { filePath, isPinned: true });
+			const absolutePath = resolveToAbsolutePath({
+				filePath,
+				workspaceRoot: workspaceCwd,
+			});
+			if (!absolutePath) return;
+			addFileViewerPane(workspaceId, {
+				filePath: absolutePath,
+				isPinned: true,
+			});
 		},
-		[addFileViewerPane, workspaceId],
+		[addFileViewerPane, workspaceCwd, workspaceId],
 	);
 	const handleCopy = useCallback(() => {
 		if (!fullText) return;

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatMastraPane/ChatMastraInterface/components/ChatMastraMessageList/components/UserMessage/components/UserMessageText/UserMessageText.tsx

@@ -1,4 +1,4 @@
-import { normalizeWorkspaceFilePath } from "../../../../../../../../ChatPane/ChatInterface/utils/file-paths";
+import { resolveToAbsolutePath } from "../../../../../../../../ChatPane/ChatInterface/utils/file-paths";
 import type { MastraMessage, MastraMessagePart } from "../../types";
 import { parseUserMentions } from "../../utils/parseUserMentions";
 
@@ -36,20 +36,20 @@ export function UserMessageText({
 						);
 					}
 
-					const normalizedPath = normalizeWorkspaceFilePath({
+					const absolutePath = resolveToAbsolutePath({
 						filePath: segment.relativePath,
 						workspaceRoot: workspaceCwd,
 					});
-					const canOpen = Boolean(normalizedPath);
+					const canOpen = Boolean(absolutePath);
 
 					return (
 						<button
 							type="button"
 							key={`${message.id}-${partIndex}-${segmentIndex}`}
 							className="mx-0.5 inline-flex items-center gap-0.5 rounded-md bg-primary/15 px-1.5 py-0.5 font-mono text-xs text-primary transition-colors hover:bg-primary/22 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/40 disabled:cursor-default disabled:opacity-60"
 							onClick={() => {
-								if (!normalizedPath) return;
-								onOpenMentionedFile(normalizedPath);
+								if (!absolutePath) return;
+								onOpenMentionedFile(absolutePath);
 							}}
 							disabled={!canOpen}
 							aria-label={`Open file ${segment.relativePath}`}

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatInterface/components/MastraToolCallBlock/MastraToolCallBlock.tsx

@@ -10,7 +10,7 @@ import { useChangesStore } from "renderer/stores/changes";
 import { useTabsStore } from "renderer/stores/tabs/store";
 import type { ChangeCategory } from "shared/changes-types";
 import { READ_ONLY_TOOLS } from "../../constants";
-import { normalizeWorkspaceFilePath } from "../../utils/file-paths";
+import { resolveToAbsolutePath } from "../../utils/file-paths";
 import type { ToolPart } from "../../utils/tool-helpers";
 import {
 	getArgs,
@@ -83,22 +83,21 @@ export function MastraToolCallBlock({
 	const toolDisplayName = toolName
 		.replace("mastra_workspace_", "")
 		.replaceAll("_", " ");
-	const normalizeFilePath = useCallback(
+	const resolveFilePath = useCallback(
 		(filePath: string) => {
-			const normalizedPath = normalizeWorkspaceFilePath({
+			return resolveToAbsolutePath({
 				filePath,
 				workspaceRoot: workspaceCwd,
 			});
-			return normalizedPath ?? null;
 		},
 		[workspaceCwd],
 	);
 	const openFileInPane = useCallback(
 		(filePath: string) => {
 			if (!workspaceId) return;
-			const normalizedPath = normalizeFilePath(filePath);
-			if (!normalizedPath) return;
-			addFileViewerPane(workspaceId, { filePath: normalizedPath });
+			const absolutePath = resolveFilePath(filePath);
+			if (!absolutePath) return;
+			addFileViewerPane(workspaceId, { filePath: absolutePath });
 			posthog.capture("chat_file_opened_from_tool", {
 				workspace_id: workspaceId,
 				session_id: sessionId ?? null,
@@ -109,7 +108,7 @@ export function MastraToolCallBlock({
 		},
 		[
 			addFileViewerPane,
-			normalizeFilePath,
+			resolveFilePath,
 			organizationId,
 			sessionId,
 			toolName,
@@ -145,21 +144,21 @@ export function MastraToolCallBlock({
 	}, [panes, tabs, workspaceId]);
 	const getDiffPaneTargetForFile = useCallback(
 		(filePath: string) => {
-			const normalizedPath = normalizeFilePath(filePath);
-			if (!normalizedPath) return null;
-			return workspaceDiffPaneByFilePath.get(normalizedPath) ?? null;
+			const absolutePath = resolveFilePath(filePath);
+			if (!absolutePath) return null;
+			return workspaceDiffPaneByFilePath.get(absolutePath) ?? null;
 		},
-		[normalizeFilePath, workspaceDiffPaneByFilePath],
+		[resolveFilePath, workspaceDiffPaneByFilePath],
 	);
 	const openFileInDiffPane = useCallback(
 		(filePath: string) => {
 			if (!workspaceId) return;
-			const normalizedPath = normalizeFilePath(filePath);
+			const absolutePath = resolveFilePath(filePath);
 			const diffPaneTarget = getDiffPaneTargetForFile(filePath);
-			if (!normalizedPath) return;
+			if (!absolutePath) return;
 
 			addFileViewerPane(workspaceId, {
-				filePath: normalizedPath,
+				filePath: absolutePath,
 				diffCategory: diffPaneTarget?.diffCategory ?? "unstaged",
 				commitHash: diffPaneTarget?.commitHash,
 				oldPath: diffPaneTarget?.oldPath,
@@ -176,7 +175,7 @@ export function MastraToolCallBlock({
 		[
 			addFileViewerPane,
 			getDiffPaneTargetForFile,
-			normalizeFilePath,
+			resolveFilePath,
 			organizationId,
 			sessionId,
 			toolName,

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatInterface/components/MessagePartsRenderer/MessagePartsRenderer.tsx

@@ -16,7 +16,7 @@ import { useTabsStore } from "renderer/stores/tabs/store";
 import { READ_ONLY_TOOLS } from "../../constants";
 import {
 	getWorkspaceToolFilePath,
-	normalizeWorkspaceFilePath,
+	resolveToAbsolutePath,
 } from "../../utils/file-paths";
 import type { ToolPart } from "../../utils/tool-helpers";
 import { getArgs, normalizeToolName } from "../../utils/tool-helpers";
@@ -63,12 +63,12 @@ export function MessagePartsRenderer({
 	const openFileInPane = useCallback(
 		(filePath: string) => {
 			if (!workspaceId) return;
-			const normalizedPath = normalizeWorkspaceFilePath({
+			const absolutePath = resolveToAbsolutePath({
 				filePath,
 				workspaceRoot: workspaceCwd,
 			});
-			if (!normalizedPath) return;
-			addFileViewerPane(workspaceId, { filePath: normalizedPath });
+			if (!absolutePath) return;
+			addFileViewerPane(workspaceId, { filePath: absolutePath });
 		},
 		[addFileViewerPane, workspaceCwd, workspaceId],
 	);

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/ChatPane/ChatInterface/utils/file-paths.ts

@@ -1,3 +1,5 @@
+import { isAbsolute, normalize, relative, resolve } from "pathe";
+
 export function getWorkspaceToolFilePath({
 	toolName,
 	args,
@@ -26,39 +28,74 @@ export function normalizeWorkspaceFilePath({
 	filePath: string;
 	workspaceRoot?: string;
 }): string | null {
-	let normalizedPath = filePath.trim();
+	let normalizedPath = stripFileUri(filePath.trim());
 	if (!normalizedPath) return null;
 
-	if (normalizedPath.startsWith("file://")) {
-		const rawPath = normalizedPath.slice(7);
-		try {
-			normalizedPath = decodeURIComponent(rawPath);
-		} catch {
-			normalizedPath = rawPath;
+	normalizedPath = normalize(normalizedPath);
+
+	if (workspaceRoot) {
+		const root = normalize(workspaceRoot);
+		if (normalizedPath === root) return null;
+		if (isAbsolute(normalizedPath)) {
+			const rel = relative(root, normalizedPath);
+			// relative() returns a path starting with ".." if outside the root
+			if (rel.startsWith("..")) return null;
+			normalizedPath = rel;
 		}
 	}
 
-	normalizedPath = normalizedPath.replaceAll("\\", "/");
+	if (!normalizedPath || normalizedPath === ".") return null;
+	if (isAbsolute(normalizedPath)) return null;
 
-	const normalizedRoot = workspaceRoot
-		? workspaceRoot.replaceAll("\\", "/").replace(/\/+$/, "")
-		: "";
+	return normalizedPath;
+}
 
-	if (normalizedRoot) {
-		if (normalizedPath === normalizedRoot) return null;
-		if (normalizedPath.startsWith(`${normalizedRoot}/`)) {
-			normalizedPath = normalizedPath.slice(normalizedRoot.length + 1);
-		}
+/**
+ * Resolves a file path to an absolute path given a workspace root.
+ * Handles file:// URIs, relative paths, and already-absolute paths.
+ * Returns null if the path is empty or resolves to the workspace root itself.
+ */
+export function resolveToAbsolutePath({
+	filePath,
+	workspaceRoot,
+}: {
+	filePath: string;
+	workspaceRoot?: string;
+}): string | null {
+	const normalizedPath = stripFileUri(filePath.trim());
+	if (!normalizedPath) return null;
+
+	// Remote URL — pass through
+	if (
+		normalizedPath.startsWith("https://") ||
+		normalizedPath.startsWith("http://")
+	) {
+		return normalizedPath;
 	}
 
-	while (normalizedPath.startsWith("./")) {
-		normalizedPath = normalizedPath.slice(2);
+	// Already absolute — normalize and return
+	if (isAbsolute(normalizedPath)) {
+		return normalize(normalizedPath);
 	}
 
-	if (!normalizedPath || normalizedPath === ".") return null;
-	if (normalizedPath.startsWith("/")) return null;
+	// Relative path — resolve against workspace root
+	if (!workspaceRoot) return null;
 
-	return normalizedPath;
+	const resolved = resolve(workspaceRoot, normalizedPath);
+	// Don't return the workspace root itself
+	if (resolved === normalize(workspaceRoot)) return null;
+
+	return resolved;
+}
+
+function stripFileUri(path: string): string {
+	if (!path.startsWith("file://")) return path;
+	const rawPath = path.slice(7);
+	try {
+		return decodeURIComponent(rawPath);
+	} catch {
+		return rawPath;
+	}
 }
 
 function toStringValue(value: unknown): string | null {

apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx

@@ -1,3 +1,4 @@
+import { basename, relative } from "pathe";
 import { useCallback, useEffect, useRef, useState } from "react";
 import type { MosaicBranch } from "react-mosaic-component";
 import { useChangesStore } from "renderer/stores/changes";
@@ -244,7 +245,13 @@ export function FileViewerPane({
 		pendingModeRef.current = null;
 	};
 
-	const fileName = filePath.split("/").pop() || filePath;
+	const fileName = basename(filePath) || filePath;
+	// Derive display path: relative for in-worktree files, absolute otherwise
+	const displayPath = (() => {
+		if (!worktreePath || !filePath.startsWith(worktreePath)) return filePath;
+		const rel = relative(worktreePath, filePath);
+		return rel.startsWith("..") ? filePath : rel;
+	})();
 	const hasRenderedMode = isMarkdownFile(filePath) || isImageFile(filePath);
 	const hasDiff = !!diffCategory;
 
@@ -262,7 +269,7 @@ export function FileViewerPane({
 					<div className="flex h-full w-full">
 						<FileViewerToolbar
 							fileName={fileName}
-							filePath={filePath}
+							filePath={displayPath}
 							isDirty={isDirty}
 							viewMode={viewMode}
 							isPinned={isPinned}
@@ -284,6 +291,7 @@ export function FileViewerPane({
 				<FileViewerContent
 					viewMode={viewMode}
 					filePath={filePath}
+					displayPath={displayPath}
 					isLoadingRaw={isLoadingRaw}
 					isLoadingImage={isLoadingImage}
 					isLoadingDiff={isLoadingDiff}