lael-labs/t3code

apps/mobile/src/features/files/ThreadFilesRouteScreen.tsx+9−2

 import { WorkspaceFileWebPreview } from "./WorkspaceFileWebPreview";
 import {
   basename,
+  isAbsolutePath,
   isMarkdownPreviewFile,
   isSvgImagePreviewFile,
   isVideoPreviewFile,
     );
   }
-  const parentDir = relativePath.split("/").slice(0, -1).join("/");
+  const parentDir = relativePath.slice(
-  const headerSubtitle = [projectName, parentDir].filter(Boolean).join(" · ");
+    0,
+    Math.max(relativePath.lastIndexOf("/"), relativePath.lastIndexOf("\\"), 0),
+  );
+  // A host file outside the workspace is not under the project name.
+  const headerSubtitle = isAbsolutePath(relativePath)
+    ? parentDir
+    : [projectName, parentDir].filter(Boolean).join(" · ");
   return (
     <ReviewHighlighterProvider>

apps/mobile/src/features/files/filePath.test.ts+14−1

@@ -1,6 +1,19 @@
1	import { describe, expect, it } from "vite-plus/test";	1	import { describe, expect, it } from "vite-plus/test";
2		2
3	import { isSvgImagePreviewFile, resolveWorkspaceRelativeFilePath } from "./filePath";	3	import {
		4	fileRoutePathSegments,
		5	isSvgImagePreviewFile,
		6	resolveWorkspaceRelativeFilePath,
		7	} from "./filePath";
		8
		9	describe("fileRoutePathSegments", () => {
		10	it("round-trips workspace-relative and host paths through the route", () => {
		11	expect(fileRoutePathSegments("src/main.ts")).toEqual(["src", "main.ts"]);
		12	expect(fileRoutePathSegments("/tmp/t3-cleanup/report.md").join("/")).toBe(
		13	"/tmp/t3-cleanup/report.md",
		14	);
		15	});
		16	});
4		17
5	describe("resolveWorkspaceRelativeFilePath", () => {	18	describe("resolveWorkspaceRelativeFilePath", () => {
6	it("keeps normalized workspace-relative paths", () => {	19	it("keeps normalized workspace-relative paths", () => {

apps/mobile/src/features/files/filePath.ts+8−1

   return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 }
-function isAbsolutePath(value: string): boolean {
+/** A file route holding an absolute path shows a host file outside the workspace. */
+export function isAbsolutePath(value: string): boolean {
   return value.startsWith("/") || isWindowsAbsolutePath(value);
 }
+/** Route segments that `normalizeRoutePath` joins back into the same path, root included. */
+export function fileRoutePathSegments(path: string): string[] {
+  const segments = path.split("/").filter((segment) => segment.length > 0);
+  return path.startsWith("/") ? ["", ...segments] : segments;
+}
 function isWindowsPathStyle(value: string): boolean {
   return isWindowsAbsolutePath(value) || /^[A-Za-z]:\\/.test(value);
 }

apps/mobile/src/features/files/workspaceFileAssetUrl.ts+10−4

 import { useMemo } from "react";
 import { useAssetUrlState, useRefreshAssetUrl } from "../../state/assets";
-import { isVideoPreviewFile, resolveWorkspaceFilePath } from "./filePath";
+import { isAbsolutePath, isVideoPreviewFile, resolveWorkspaceFilePath } from "./filePath";
 export function useWorkspaceFileAssetUrlState(props: {
   readonly cwd: string | null;
     [props.cwd, props.relativePath],
   );
+  // Videos stream from an exact-file URL, and so does anything outside the
+  // workspace, where no workspace-scoped URL can exist.
+  const relativePath = props.relativePath;
   const resource = useMemo<AssetResource | null>(
     () =>
-      absolutePath !== null && props.threadId !== null
+      absolutePath !== null && relativePath !== null && props.threadId !== null
         ? {
-            _tag: isVideoPreviewFile(absolutePath) ? "media-file" : "workspace-file",
+            _tag:
+              isVideoPreviewFile(absolutePath) || isAbsolutePath(relativePath)
+                ? "media-file"
+                : "workspace-file",
             threadId: props.threadId,
             path: absolutePath,
           }
         : null,
-    [absolutePath, props.threadId],
+    [absolutePath, relativePath, props.threadId],
   );
   const state = useAssetUrlState(props.environmentId, resource);
   const refresh = useRefreshAssetUrl(props.environmentId, resource);

apps/mobile/src/features/threads/ThreadFeed.tsx+36−2

@@ -166,7 +166,12 @@ import { · 165 unmodified lines
166	import { useAtomQueryRunner } from "../../state/use-atom-query-runner";	166	import { useAtomQueryRunner } from "../../state/use-atom-query-runner";
167	import { usePreparedConnection } from "../../state/session";	167	import { usePreparedConnection } from "../../state/session";
168	import * as Option from "effect/Option";	168	import * as Option from "effect/Option";
169	import { resolveWorkspaceRelativeFilePath } from "../files/filePath";	169	import {
		170	basename,
		171	fileRoutePathSegments,
		172	isAbsolutePath,
		173	resolveWorkspaceRelativeFilePath,
		174	} from "../files/filePath";
170	import { MARKDOWN_IMAGE_MAX_WIDTH, resolveMarkdownImageDisplaySize } from "./markdownImageSize";	175	import { MARKDOWN_IMAGE_MAX_WIDTH, resolveMarkdownImageDisplaySize } from "./markdownImageSize";
171		176
172	const WIDE_MARKDOWN_BLOCK_OPTIONS = {	177	const WIDE_MARKDOWN_BLOCK_OPTIONS = {
@@ -2068,7 +2073,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { · 1895 unmodified lines
2068	navigation.navigate("ThreadFile", {	2073	navigation.navigate("ThreadFile", {
2069	environmentId: String(props.environmentId),	2074	environmentId: String(props.environmentId),
2070	threadId: String(props.threadId),	2075	threadId: String(props.threadId),
2071	path: relativePath.split("/").filter((segment) => segment.length > 0),	2076	path: fileRoutePathSegments(relativePath),
2072	...(presentation.line ? { line: String(presentation.line) } : {}),	2077	...(presentation.line ? { line: String(presentation.line) } : {}),
2073	});	2078	});
2074	return;	2079	return;
@@ -2090,6 +2095,35 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { · 15 unmodified lines
2090	return;	2095	return;
2091	}	2096	}
2092		2097
		2098	// A host file outside the workspace, such as a report an agent wrote to
		2099	// a temp directory, opens read-only in the file screen.
		2100	if (presentation.kind === "file" && isAbsolutePath(presentation.path)) {
		2101	void Haptics.selectionAsync();
		2102	if (isPdfFile({ name: presentation.path })) {
		2103	setExpandedFile(
		2104	(current) =>
		2105	current ?? {
		2106	kind: "pdf",
		2107	name: basename(presentation.path),
		2108	environmentId: props.environmentId,
		2109	resource: {
		2110	_tag: "media-file",
		2111	threadId: props.threadId,
		2112	path: presentation.path,
		2113	},
		2114	},
		2115	);
		2116	return;
		2117	}
		2118	navigation.navigate("ThreadFile", {
		2119	environmentId: String(props.environmentId),
		2120	threadId: String(props.threadId),
		2121	path: fileRoutePathSegments(presentation.path),
		2122	...(presentation.line ? { line: String(presentation.line) } : {}),
		2123	});
		2124	return;
		2125	}
		2126
2093	if (presentation.kind !== "file" && presentation.href) {	2127	if (presentation.kind !== "file" && presentation.href) {
2094	if (/^https?:\/\//i.test(presentation.href) && isPdfFile({ name: presentation.href })) {	2128	if (/^https?:\/\//i.test(presentation.href) && isPdfFile({ name: presentation.href })) {
2095	setExpandedFile(	2129	setExpandedFile(

apps/server/src/assets/AssetAccess.test.ts+6−4

 ).pipe(Layer.provideMerge(NodeServices.layer));
 describe("AssetAccess", () => {
-  it.effect("issues exact URLs for images and videos outside the workspace", () =>
+  it.effect("issues exact URLs for media and browser documents outside the workspace", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
         ["screenshot.png", "image/png"],
         ["recording.mp4", "video/mp4"],
         ["recording.webm", "video/webm"],
+        ["report.html", "text/html"],
+        ["report.pdf", "application/pdf"],
       ] as const) {
         const filePath = path.join(outside, name);
         yield* fs.writeFileString(filePath, "media");
     }).pipe(Effect.provide(testLayer)),
   );
-  it.effect("rejects non-media files, disguised targets, and directories", () =>
+  it.effect("rejects non-previewable files, disguised targets, and directories", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
       const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-media-validation-" });
-      for (const name of ["report.html", "secret.txt", "secret.%70ng", "secret.png#private.txt"]) {
+      for (const name of ["report.md", "secret.txt", "secret.%70ng", "secret.png#private.txt"]) {
         const filePath = path.join(root, name);
         yield* fs.writeFileString(filePath, "not media");
         const error = yield* issueAssetUrl({
         expect(error).toBeInstanceOf(AssetPreviewTypeValidationError);
       }
       const disguisedPath = path.join(root, "disguised.png");
-      yield* fs.symlink(path.join(root, "report.html"), disguisedPath);
+      yield* fs.symlink(path.join(root, "secret.txt"), disguisedPath);
       const disguisedError = yield* issueAssetUrl({
         resource: { _tag: "media-file", threadId: ThreadId.make("thread-1"), path: disguisedPath },
       }).pipe(Effect.flip);

apps/server/src/assets/AssetAccess.ts+3−3

   AssetWorkspaceRootNormalizationError,
 } from "@t3tools/contracts";
 import {
+  hostPreviewMimeTypeFromExtension,
   isWorkspaceImagePreviewPath,
   isWorkspacePreviewEntryPath,
-  mediaMimeTypeFromExtension,
   WORKSPACE_BROWSER_PREVIEW_EXTENSIONS,
   WORKSPACE_IMAGE_PREVIEW_EXTENSIONS,
 } from "@t3tools/shared/filePreview";
       if (!canonicalFile) {
         return yield* new AssetWorkspaceAssetNotFoundError({ resource: input.resource });
       }
-      if (mediaMimeTypeFromExtension(path.extname(canonicalFile)) === null) {
+      if (hostPreviewMimeTypeFromExtension(path.extname(canonicalFile)) === null) {
         return yield* new AssetPreviewTypeValidationError({ resource: input.resource });
       }
       const identity = yield* openMediaFile(canonicalFile).pipe(
       Effect.orElseSucceed(() => null),
     );
     if (canonicalFile !== claims.filePath) return null;
-    const mimeType = mediaMimeTypeFromExtension(path.extname(canonicalFile));
+    const mimeType = hostPreviewMimeTypeFromExtension(path.extname(canonicalFile));
     if (!mimeType) return null;
     const file = yield* openMediaFile(canonicalFile, claims).pipe(
       Effect.tapError((cause) =>

apps/server/src/http.test.ts+7−9

@@ -324,15 +324,13 @@ describe("assetResponseHeaders", () => { · 323 unmodified lines
324	"X-Content-Type-Options": "nosniff",	324	"X-Content-Type-Options": "nosniff",
325	});	325	});
326	});	326	});
327	it("declares utf-8 for HTML assets so non-ASCII content renders correctly", () => {	327	it("serves HTML assets as utf-8 inside a sandboxed origin", () => {
328	expect(assetResponseHeaders("/workspace/page.html")).toHaveProperty(	328	for (const path of ["/workspace/page.html", "/workspace/PAGE.HTM", "/tmp/report.html"]) {
329	"Content-Type",	329	expect(assetResponseHeaders(path)).toMatchObject({
330	"text/html; charset=utf-8",	330	"Content-Type": "text/html; charset=utf-8",
331	);	331	"Content-Security-Policy": "sandbox allow-scripts allow-forms allow-popups allow-modals",
332	expect(assetResponseHeaders("/workspace/PAGE.HTM")).toHaveProperty(	332	});
333	"Content-Type",	333	}
334	"text/html; charset=utf-8",
335	);
336	});	334	});
337		335
338	it("downloads uploaded documents without executing their content", () => {	336	it("downloads uploaded documents without executing their content", () => {

apps/server/src/http.ts+8−1

 const LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "::1", "localhost"]);
 const DESKTOP_RENDERER_ORIGINS = ["t3code://app", "t3code-dev://app"];
 const SVG_CONTENT_SECURITY_POLICY = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
+// HTML previews are agent output, not the app. The sandbox gives the document an
+// opaque origin: scripts run, but same-origin cookies, storage, and API calls are
+// out of reach. Relative sibling assets still load through their signed URLs.
+const HTML_CONTENT_SECURITY_POLICY = "sandbox allow-scripts allow-forms allow-popups allow-modals";
 // Types a browser may render as a document if a proxy strips the disposition
 // header. Downloads of these fall back to octet-stream.
       : inlineVideoMimeType !== undefined && isSafeInlineVideoMimeType(inlineVideoMimeType)
         ? { "Content-Type": inlineVideoMimeType }
         : lowerPath.endsWith(".html") || lowerPath.endsWith(".htm")
-          ? { "Content-Type": "text/html; charset=utf-8" }
+          ? {
+              "Content-Type": "text/html; charset=utf-8",
+              "Content-Security-Policy": HTML_CONTENT_SECURITY_POLICY,
+            }
           : {}),
     ...(!options?.download && lowerPath.endsWith(".svg")
       ? { "Content-Security-Policy": SVG_CONTENT_SECURITY_POLICY }

apps/server/src/workspace/WorkspaceFileSystem.test.ts+66−0

@@ -1,3 +1,6 @@
		1	// @effect-diagnostics nodeBuiltinImport:off - FileSystem cannot create a FIFO.
		2	import * as NodeChildProcess from "node:child_process";
		3
1	import * as NodeServices from "@effect/platform-node/NodeServices";	4	import * as NodeServices from "@effect/platform-node/NodeServices";
2	import { it, describe, expect } from "@effect/vitest";	5	import { it, describe, expect } from "@effect/vitest";
3	import * as Effect from "effect/Effect";	6	import * as Effect from "effect/Effect";
@@ -73,6 +76,53 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceFileSystemLive", (i · 69 unmodified lines
73	}),	76	}),
74	);	77	);
75		78
		79	it.effect("reads host files outside the workspace root by absolute path", () =>
		80	Effect.gen(function* () {
		81	const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
		82	const path = yield* Path.Path;
		83	const cwd = yield* makeTempDir;
		84	const outsideDir = yield* makeTempDir;
		85	yield* writeTextFile(outsideDir, "cleanup-report.md", "# Report\n");
		86	const absolutePath = path.join(outsideDir, "cleanup-report.md");
		87
		88	const result = yield* workspaceFileSystem.readFile({
		89	cwd,
		90	relativePath: absolutePath,
		91	});
		92
		93	expect(result).toEqual({
		94	relativePath: absolutePath,
		95	contents: "# Report\n",
		96	byteLength: 9,
		97	truncated: false,
		98	});
		99	}),
		100	);
		101
		102	it.effect("rejects a FIFO without blocking on open", () =>
		103	Effect.gen(function* () {
		104	const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
		105	const path = yield* Path.Path;
		106	const cwd = yield* makeTempDir;
		107	const outsideDir = yield* makeTempDir;
		108	const fifoPath = path.join(outsideDir, "pipe");
		109	yield* Effect.promise(
		110	() =>
		111	new Promise<void>((resolve, reject) =>
		112	NodeChildProcess.execFile("mkfifo", [fifoPath], (error) =>
		113	error ? reject(error) : resolve(),
		114	),
		115	),
		116	);
		117
		118	const error = yield* workspaceFileSystem
		119	.readFile({ cwd, relativePath: fifoPath })
		120	.pipe(Effect.flip);
		121
		122	expect(error).toBeInstanceOf(WorkspaceFileSystem.WorkspacePathNotFileError);
		123	}),
		124	);
		125
76	it.effect("rejects reads outside the workspace root", () =>	126	it.effect("rejects reads outside the workspace root", () =>
77	Effect.gen(function* () {	127	Effect.gen(function* () {
78	const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;	128	const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
@@ -212,6 +262,22 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceFileSystemLive", (i · 133 unmodified lines
212	}),	262	}),
213	);	263	);
214		264
		265	it.effect("rejects writes by absolute path", () =>
		266	Effect.gen(function* () {
		267	const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
		268	const path = yield* Path.Path;
		269	const cwd = yield* makeTempDir;
		270	const outsideDir = yield* makeTempDir;
		271	const absolutePath = path.join(outsideDir, "cleanup-report.md");
		272
		273	const error = yield* workspaceFileSystem
		274	.writeFile({ cwd, relativePath: absolutePath, contents: "# Edited\n" })
		275	.pipe(Effect.flip);
		276
		277	expect(error).toBeInstanceOf(WorkspacePaths.WorkspacePathOutsideRootError);
		278	}),
		279	);
		280
215	it.effect("invalidates workspace entry search cache after writes", () =>	281	it.effect("invalidates workspace entry search cache after writes", () =>
216	Effect.gen(function* () {	282	Effect.gen(function* () {
217	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;	283	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;

apps/server/src/workspace/WorkspaceFileSystem.ts+48−6

@@ -3,10 +3,13 @@ · 2 unmodified lines
3	* WorkspaceFileSystem - Effect service contract for workspace file mutations.	3	* WorkspaceFileSystem - Effect service contract for workspace file mutations.
4	*	4	*
5	* Owns workspace-root-relative file read/write operations and their associated	5	* Owns workspace-root-relative file read/write operations and their associated
6	* safety checks and cache invalidation hooks.	6	* safety checks and cache invalidation hooks. Reads also accept absolute host
		7	* paths so clients can show files an agent left outside the workspace; writes
		8	* never leave the root.
7	*	9	*
8	* @module WorkspaceFileSystem	10	* @module WorkspaceFileSystem
9	*/	11	*/
		12	import * as NodeFS from "node:fs";
10	import * as NodeFSP from "node:fs/promises";	13	import * as NodeFSP from "node:fs/promises";
11		14
12	import type {	15	import type {
@@ -104,7 +107,10 @@ export type WorkspaceFileSystemError = typeof WorkspaceFileSystemError.Type; · 91 unmodified lines
104	export class WorkspaceFileSystem extends Context.Service<	107	export class WorkspaceFileSystem extends Context.Service<
105	WorkspaceFileSystem,	108	WorkspaceFileSystem,
106	{	109	{
107	/** Read a UTF-8 text file relative to the workspace root. */	110	/**
		111	* Read a UTF-8 text file relative to the workspace root, or any host file by
		112	* absolute path.
		113	*/
108	readonly readFile: (	114	readonly readFile: (
109	input: ProjectReadFileInput,	115	input: ProjectReadFileInput,
110	) => Effect.Effect<	116	) => Effect.Effect<
@@ -132,9 +138,31 @@ export const make = Effect.gen(function* () { · 21 unmodified lines
132	const workspacePaths = yield* WorkspacePaths.WorkspacePaths;	138	const workspacePaths = yield* WorkspacePaths.WorkspacePaths;
133	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;	139	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
134		140
135	const readFile: WorkspaceFileSystem["Service"]["readFile"] = Effect.fn(	141	/**
136	"WorkspaceFileSystem.readFile",	142	* Resolves the file a read targets. Workspace-relative paths must stay inside the
137	)(function* (input) {	143	* root, symlinks included. An absolute path reads a host file in place, such as a
		144	* report an agent wrote to a temp directory; it gets no root check.
		145	*/
		146	const resolveReadTarget = Effect.fn("WorkspaceFileSystem.resolveReadTarget")(function* (
		147	input: ProjectReadFileInput,
		148	) {
		149	const requestedPath = input.relativePath.trim();
		150	if (path.isAbsolute(requestedPath)) {
		151	const realTargetPath = yield* Effect.tryPromise({
		152	try: () => NodeFSP.realpath(requestedPath),
		153	catch: (cause) =>
		154	new WorkspaceFileSystemOperationError({
		155	workspaceRoot: input.cwd,
		156	relativePath: input.relativePath,
		157	resolvedPath: requestedPath,
		158	operationPath: requestedPath,
		159	operation: "realpath-target",
		160	cause,
		161	}),
		162	});
		163	return { relativePath: requestedPath, realTargetPath };
		164	}
		165
138	const target = yield* workspacePaths.resolveRelativePathWithinRoot({	166	const target = yield* workspacePaths.resolveRelativePathWithinRoot({
139	workspaceRoot: input.cwd,	167	workspaceRoot: input.cwd,
140	relativePath: input.relativePath,	168	relativePath: input.relativePath,
@@ -177,10 +205,24 @@ export const make = Effect.gen(function* () { · 36 unmodified lines
177	resolvedPath: realTargetPath,	205	resolvedPath: realTargetPath,
178	});	206	});
179	}	207	}
		208	return { relativePath: target.relativePath, realTargetPath };
		209	});
		210
		211	const readFile: WorkspaceFileSystem["Service"]["readFile"] = Effect.fn(
		212	"WorkspaceFileSystem.readFile",
		213	)(function* (input) {
		214	const target = yield* resolveReadTarget(input);
		215	const realTargetPath = target.realTargetPath;
180		216
181	return yield* Effect.acquireUseRelease(	217	return yield* Effect.acquireUseRelease(
182	Effect.tryPromise({	218	Effect.tryPromise({
183	try: () => NodeFSP.open(realTargetPath, "r"),	219	// Non-blocking so a FIFO cannot hang the open; the stat below rejects
		220	// it. Regular files ignore the flag. Windows lacks it.
		221	try: () =>
		222	NodeFSP.open(
		223	realTargetPath,
		224	NodeFS.constants.O_RDONLY \| (NodeFS.constants.O_NONBLOCK ?? 0),
		225	),
184	catch: (cause) =>	226	catch: (cause) =>
185	new WorkspaceFileSystemOperationError({	227	new WorkspaceFileSystemOperationError({
186	workspaceRoot: input.cwd,	228	workspaceRoot: input.cwd,

apps/web/src/browser/openFileInPreview.ts+9−1

   PreviewSessionSnapshot,
   ScopedThreadRef,
 } from "@t3tools/contracts";
+import { mediaFileReference } from "@t3tools/client-runtime/media-reference";
 import {
   type AtomCommandResult,
   mapAtomCommandResult,
   });
 }
+/**
+ * Opens a browser document in the integrated browser. Inside the workspace the
+ * page may load sibling assets; a file outside it is served on its own.
+ */
 export async function openFileInPreview<AssetError, PreviewError>(input: {
   readonly threadRef: ScopedThreadRef;
   readonly filePath: string;
+  readonly workspaceRoot: string | undefined;
   readonly httpBaseUrl: string;
   readonly createAssetUrl: (input: {
     readonly environmentId: EnvironmentId;
       ),
     );
   }
+  const insideWorkspace =
+    mediaFileReference(input.filePath, input.workspaceRoot).relativePath !== undefined;
   const assetResult = await input.createAssetUrl({
     environmentId: input.threadRef.environmentId,
     input: {
       resource: {
-        _tag: "workspace-file",
+        _tag: insideWorkspace ? "workspace-file" : "media-file",
         threadId: input.threadRef.threadId,
         path: input.filePath,
       },

apps/web/src/components/ChatMarkdown.tsx+33−23

 } from "~/lib/openPullRequestLink";
 import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
 import { isPreviewSupportedInRuntime } from "../previewStateStore";
-import { resolvePathLinkTarget } from "../terminal-links";
+import { isAbsolutePath, resolvePathLinkTarget } from "../terminal-links";
 import {
   isBrowserPreviewFile,
   openFileInPreview,
   parseRawHtml?: boolean;
   /** Append a prompt that invokes a newly created artifact-template skill. */
   onUseArtifactTemplate?: ((template: CodexArtifactTemplate) => void) | undefined;
+  /** Directory that anchors relative links and images; defaults to `cwd`. Set
+      to the file's own directory when rendering a markdown file. */
   imageBaseDir?: string | undefined;
   onImageExpand?: ((preview: ExpandedImagePreview) => void) | undefined;
   extraRemarkPlugins?: NonNullable<ReactMarkdownOptions["remarkPlugins"]>;
   targetPath: string;
   iconPath: string;
   displayPath: string;
-  workspaceRelativePath: string | null;
+  /** What the files panel opens: workspace-relative inside the workspace, the
+      absolute host path outside it, null when the panel cannot show the file. */
+  panelPath: string | null;
   line?: number | undefined;
   label: string;
   copyMarkdown: string;
   theme: "light" | "dark";
   threadRef?: ScopedThreadRef | undefined;
   onOpen?: ((targetPath: string) => Promise<AtomCommandResult<unknown, unknown>>) | undefined;
-  onOpenInPanel: (workspaceRelativePath: string, line: number | undefined) => void;
+  onOpenInPanel: (panelPath: string, line: number | undefined) => void;
   openInEditorMenuLabel: string;
   onOpenInBrowser?: (() => Promise<AtomCommandResult<unknown, unknown>>) | undefined;
   onOpenMedia?: (() => void) | undefined;
   targetPath,
   iconPath,
   displayPath,
-  workspaceRelativePath,
+  panelPath,
   line,
   label,
   copyMarkdown,
   }, [onOpen, targetPath]);
   const handleOpenInFilePreview = useCallback(() => {
-    if (threadRef && workspaceRelativePath) {
+    if (threadRef && panelPath) {
-      onOpenInPanel(workspaceRelativePath, line);
+      onOpenInPanel(panelPath, line);
       return;
     }
     if (onOpenMedia) {
       return;
     }
     handleOpenInEditor();
-  }, [handleOpenInEditor, line, onOpenInPanel, onOpenMedia, threadRef, workspaceRelativePath]);
+  }, [handleOpenInEditor, line, onOpenInPanel, onOpenMedia, panelPath, threadRef]);
   const handleOpenInBrowser = useCallback(() => {
     if (!onOpenInBrowser) {
   const canOpenInEditor = onOpen !== undefined;
   const canOpenInBrowser = onOpenInBrowser !== undefined;
-  const canOpenInPanel = threadRef !== undefined && Boolean(workspaceRelativePath);
+  const canOpenInPanel = threadRef !== undefined && Boolean(panelPath);
   const hasPrimaryAction = hasMarkdownFilePrimaryAction({
     canOpenInEditor,
     canOpenInBrowser,
     previous.targetPath === next.targetPath &&
     previous.iconPath === next.iconPath &&
     previous.displayPath === next.displayPath &&
-    previous.workspaceRelativePath === next.workspaceRelativePath &&
+    previous.panelPath === next.panelPath &&
     previous.line === next.line &&
     previous.label === next.label &&
     previous.copyMarkdown === next.copyMarkdown &&
     for (const href of extractMarkdownLinkHrefs(renderCodexFileCitationsAsMarkdown(text))) {
       const normalizedHref = normalizeMarkdownLinkHrefKey(href);
       if (metaByHref.has(normalizedHref)) continue;
-      const meta = resolveMarkdownFileLinkMeta(normalizedHref, cwd);
+      const meta = resolveMarkdownFileLinkMeta(normalizedHref, cwd, imageBaseDir ?? cwd);
       if (meta) {
         metaByHref.set(normalizedHref, meta);
       }
     }
     return metaByHref;
-  }, [cwd, text]);
+  }, [cwd, imageBaseDir, text]);
   const inlineCodeFileLinkMetaByText = useMemo(() => {
     const metaByText = new Map<string, MarkdownFileLinkMeta>();
     for (const span of extractInlineCodeSpans(text)) {
       if (metaByText.has(span)) continue;
-      const meta = resolveInlineCodeFileLinkMeta(span, cwd);
+      const meta = resolveInlineCodeFileLinkMeta(span, cwd, imageBaseDir ?? cwd);
       if (meta) {
         metaByText.set(span, meta);
       }
     }
     return metaByText;
-  }, [cwd, text]);
+  }, [cwd, imageBaseDir, text]);
   const fileLinkParentSuffixByPath = useMemo(() => {
     const filePaths = [
       ...[...markdownFileLinkMetaByHref.values()].map((meta) => meta.filePath),
       return openFileInPreview({
         threadRef,
         filePath: path,
+        workspaceRoot: cwd,
         httpBaseUrl: preparedConnection.value.httpBaseUrl,
         createAssetUrl,
         openPreview,
       });
     },
-    [createAssetUrl, openPreview, preparedConnection, threadRef],
+    [createAssetUrl, cwd, openPreview, preparedConnection, threadRef],
   );
   const findWorkspaceBasenameMatch = useCallback(
     async (workspaceRelativePath: string) => {
     [cwd, environmentId, searchProjectEntries],
   );
   // A bare filename resolves to the workspace root, which is rarely where the
-  // file is, so ask the index before opening.
+  // file is, so ask the index before opening. Absolute host paths open as-is.
   const openFileInPanel = useCallback(
-    (workspaceRelativePath: string, line: number | undefined) => {
+    (panelPath: string, line: number | undefined) => {
       if (!threadRef) return;
       // Claimed on every open so a synchronous one supersedes a lookup already
       // in flight.
       const isLatestLookup = claimWorkspaceBasenameLookup();
       const openAt = (path: string) =>
         useRightPanelStore.getState().openFile(threadRef, path, line);
-      if (!cwd || !needsWorkspaceBasenameLookup(workspaceRelativePath)) {
+      if (!cwd || !needsWorkspaceBasenameLookup(panelPath)) {
-        openAt(workspaceRelativePath);
+        openAt(panelPath);
         return;
       }
       void (async () => {
-        const match = await findWorkspaceBasenameMatch(workspaceRelativePath);
+        const match = await findWorkspaceBasenameMatch(panelPath);
         if (!isLatestLookup()) return;
-        openAt(match ?? workspaceRelativePath);
+        openAt(match ?? panelPath);
       })();
     },
     [cwd, findWorkspaceBasenameMatch, threadRef],
         mediaMimeTypeFromExtension(
           fileLinkMeta.basename.slice(fileLinkMeta.basename.lastIndexOf(".")),
         ) !== null;
+      // Media outside the workspace keeps the expanded preview; other host
+      // files (a report in a temp dir) open read-only in the files panel.
+      const panelPath =
+        fileLinkMeta.workspaceRelativePath ??
+        (!canPreviewMedia && isAbsolutePath(fileLinkMeta.filePath) ? fileLinkMeta.filePath : null);
       return (
         <MarkdownFileLink
           targetPath={fileLinkMeta.targetPath}
           iconPath={fileLinkMeta.filePath}
           displayPath={fileLinkMeta.displayPath}
-          workspaceRelativePath={fileLinkMeta.workspaceRelativePath}
+          panelPath={panelPath}
           line={fileLinkMeta.line}
           label={labelParts.join(" · ")}
           copyMarkdown={copyMarkdown}
         const normalizedHref = href ? normalizeMarkdownLinkHrefKey(href) : "";
         const fileLinkMeta = normalizedHref
           ? (markdownFileLinkMetaByHref.get(normalizedHref) ??
-            resolveMarkdownFileLinkMeta(normalizedHref, cwd))
+            resolveMarkdownFileLinkMeta(normalizedHref, cwd, imageBaseDir ?? cwd))
           : null;
         if (!fileLinkMeta) {
           const faviconHost = resolveExternalWebLinkHost(href);
           const codeText = nodeToPlainText(children);
           const fileLinkMeta =
             inlineCodeFileLinkMetaByText.get(codeText.trim()) ??
-            resolveInlineCodeFileLinkMeta(codeText, cwd);
+            resolveInlineCodeFileLinkMeta(codeText, cwd, imageBaseDir ?? cwd);
           if (fileLinkMeta) {
             return fileLinkChip(
               fileLinkMeta,

apps/web/src/components/RightPanelTabs.tsx+3−1

     case "files":
       return "Files";
     case "file":
-      return surface.relativePath.slice(surface.relativePath.lastIndexOf("/") + 1);
+      return surface.relativePath.slice(
+        Math.max(surface.relativePath.lastIndexOf("/"), surface.relativePath.lastIndexOf("\\")) + 1,
+      );
     case "terminal":
       return (
         terminalLabelsById.get(surface.activeTerminalId) ??

apps/web/src/components/files/FilePreviewPanel.tsx+22−12

 import { PREFERRED_HIGHLIGHTER } from "~/lib/syntaxHighlighting";
 import { cn } from "~/lib/utils";
 import { isPreviewSupportedInRuntime } from "~/previewStateStore";
-import { resolvePathLinkTarget } from "~/terminal-links";
+import { isAbsolutePath, resolvePathLinkTarget } from "~/terminal-links";
 import { ScrollArea } from "~/components/ui/scroll-area";
 import { Toggle } from "~/components/ui/toggle";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
   relativePath,
   contents,
   threadRef,
+  readOnly,
   onPendingChange,
 }: Omit<
   EditableFileSurfaceProps,
   | "onPostRender"
 > & {
   threadRef: ScopedThreadRef;
+  readOnly: boolean;
 }) {
   const saveCoordinator = useFileSaveCoordinator({
     environmentId,
         cwd={cwd}
         relativePath={relativePath}
         threadRef={threadRef}
-        onTaskListChange={({ markerOffset, checked }) => {
+        onTaskListChange={
-          const currentContents =
+          readOnly
-            getOptimisticProjectFileQueryData(environmentId, cwd, relativePath)?.contents ??
+            ? undefined
-            contents;
+            : ({ markerOffset, checked }) => {
-          const nextContents = setMarkdownTaskChecked(currentContents, markerOffset, checked);
+                const currentContents =
-          if (nextContents === currentContents) return;
+                  getOptimisticProjectFileQueryData(environmentId, cwd, relativePath)?.contents ??
-          setProjectFileQueryData(environmentId, cwd, relativePath, nextContents);
+                  contents;
-          saveCoordinator.change(nextContents);
+                const nextContents = setMarkdownTaskChecked(currentContents, markerOffset, checked);
-        }}
+                if (nextContents === currentContents) return;
+                setProjectFileQueryData(environmentId, cwd, relativePath, nextContents);
+                saveCoordinator.change(nextContents);
+              }
+        }
       />
     </ScrollArea>
   );
   const isVideo = relativePath !== null && isWorkspaceVideoPreviewPath(relativePath);
   const isImage = relativePath !== null && !isVideo && isWorkspaceImagePreviewPath(relativePath);
   const isMedia = isImage || isVideo;
+  // A file outside the workspace (an absolute path) is shown, never edited.
+  const isHostFile = relativePath !== null && isAbsolutePath(relativePath);
   const file = useProjectFileQuery(environmentId, cwd, relativePath, !isMedia);
   const [explorerOpen, setExplorerOpen] = useState(initialExplorerOpen);
   // Reading markdown rendered is a preference, not a property of one file. Keeping
       const result = await openFileInPreview({
         threadRef,
         filePath: absolutePath,
+        workspaceRoot: cwd,
         httpBaseUrl: environmentHttpBaseUrl,
         createAssetUrl,
         openPreview,
         }),
       );
     })();
-  }, [absolutePath, createAssetUrl, environmentHttpBaseUrl, openPreview, threadRef]);
+  }, [absolutePath, createAssetUrl, cwd, environmentHttpBaseUrl, openPreview, threadRef]);
   return (
     <div className="flex min-h-0 flex-1 flex-col overflow-hidden bg-background">
                 relativePath={relativePath}
                 threadRef={threadRef}
                 contents={file.data.contents}
+                readOnly={isHostFile}
                 onPendingChange={onPendingChange}
               />
-            ) : file.data.truncated ? (
+            ) : file.data.truncated || isHostFile ? (
               <Virtualizer
                 key={`${relativePath}:${resolvedTheme}:${file.data.byteLength}`}
                 className="file-preview-virtualizer min-h-0 flex-1 overflow-auto"

apps/web/src/components/files/filePath.test.ts+19−1

@@ -14,10 +14,28 @@ describe("fileBreadcrumbs", () => { · 13 unmodified lines
14	});	14	});
15		15
16	it("normalizes repeated separators", () => {	16	it("normalizes repeated separators", () => {
17	expect(fileBreadcrumbs("workspace", "/src//index.ts").map((crumb) => crumb.label)).toEqual([	17	expect(fileBreadcrumbs("workspace", "src//index.ts").map((crumb) => crumb.label)).toEqual([
18	"workspace",	18	"workspace",
19	"src",	19	"src",
20	"index.ts",	20	"index.ts",
21	]);	21	]);
22	});	22	});
		23
		24	it("starts host paths outside the workspace at the filesystem root", () => {
		25	expect(fileBreadcrumbs("t3code", "/tmp/t3-cleanup/report.md")).toEqual([
		26	{ label: "tmp", path: "/tmp", kind: "directory" },
		27	{ label: "t3-cleanup", path: "/tmp/t3-cleanup", kind: "directory" },
		28	{ label: "report.md", path: "/tmp/t3-cleanup/report.md", kind: "file" },
		29	]);
		30	expect(fileBreadcrumbs("t3code", "C:\\Temp\\report.md")).toEqual([
		31	{ label: "C:", path: "C:", kind: "directory" },
		32	{ label: "Temp", path: "C:\\Temp", kind: "directory" },
		33	{ label: "report.md", path: "C:\\Temp\\report.md", kind: "file" },
		34	]);
		35	expect(fileBreadcrumbs("t3code", "\\\\server\\share\\report.md").map((c) => c.path)).toEqual([
		36	"\\\\server",
		37	"\\\\server\\share",
		38	"\\\\server\\share\\report.md",
		39	]);
		40	});
23	});	41	});

apps/web/src/components/files/filePath.ts+14−3

+import { isWindowsAbsolutePath } from "@t3tools/shared/path";
+import { isAbsolutePath } from "~/terminal-links";
 export interface FileBreadcrumb {
   label: string;
   path: string;
   kind: "project" | "directory" | "file";
 }
+/**
+ * Crumbs for a workspace-relative path start at the project. An absolute host
+ * path is outside the workspace, so its crumbs start at the filesystem root.
+ */
 export function fileBreadcrumbs(projectName: string, relativePath: string): FileBreadcrumb[] {
-  const parts = relativePath.split("/").filter(Boolean);
+  const hostPath = isAbsolutePath(relativePath);
+  const separator = isWindowsAbsolutePath(relativePath) ? "\\" : "/";
+  const parts = relativePath.split(/[\\/]/).filter(Boolean);
+  const root = relativePath.startsWith("\\\\") ? "\\\\" : hostPath && separator === "/" ? "/" : "";
   return [
-    { label: projectName, path: "", kind: "project" },
+    ...(hostPath ? [] : [{ label: projectName, path: "", kind: "project" as const }]),
     ...parts.map((part, index) => ({
       label: part,
-      path: parts.slice(0, index + 1).join("/"),
+      path: root + parts.slice(0, index + 1).join(separator),
       kind: index === parts.length - 1 ? ("file" as const) : ("directory" as const),
     })),
   ];

apps/web/src/markdown-links.test.ts+16−0

@@ -275,6 +275,22 @@ describe("resolveMarkdownFileLinkTarget", () => { · 274 unmodified lines
275	});	275	});
276	});	276	});
277		277
		278	describe("relative links inside a rendered host file", () => {
		279	it("anchor to the file's directory while workspace membership follows cwd", () => {
		280	const meta = resolveMarkdownFileLinkMeta("appendix.md", "/repo", "/tmp/report");
		281	expect(meta).toMatchObject({
		282	filePath: "/tmp/report/appendix.md",
		283	workspaceRelativePath: null,
		284	});
		285	const inline = resolveInlineCodeFileLinkMeta("Makefile:12", "/repo", "/tmp/report");
		286	expect(inline).toMatchObject({ filePath: "/tmp/report/Makefile", line: 12 });
		287	expect(resolveMarkdownFileLinkMeta("src/main.ts", "/repo", "/repo/docs")).toMatchObject({
		288	filePath: "/repo/docs/src/main.ts",
		289	workspaceRelativePath: "docs/src/main.ts",
		290	});
		291	});
		292	});
		293
278	describe("resolveInlineCodeFileLinkMeta", () => {	294	describe("resolveInlineCodeFileLinkMeta", () => {
279	it("links relative paths with file extensions", () => {	295	it("links relative paths with file extensions", () => {
280	expect(	296	expect(

apps/web/src/markdown-links.ts+14−6

   return !POSITION_ONLY_PATTERN.test(rest);
 }
+/**
+ * `baseDir` anchors relative links; it defaults to the workspace root and is the
+ * file's own directory when rendering a markdown file. `cwd` stays the workspace
+ * root so the result still knows whether the target is inside it.
+ */
 export function resolveMarkdownFileLinkTarget(
   href: string | undefined,
   cwd?: string,
+  baseDir: string | undefined = cwd,
 ): string | null {
   if (!href) return null;
   const rawHref = normalizeMarkdownLinkDestination(href);
     return pathWithPosition;
   }
-  if (!cwd) return null;
+  if (!baseDir) return null;
-  return resolvePathLinkTarget(pathWithPosition, cwd);
+  return resolvePathLinkTarget(pathWithPosition, baseDir);
 }
 /**
 export function resolveInlineCodeFileLinkMeta(
   codeText: string,
   cwd?: string,
+  baseDir: string | undefined = cwd,
 ): MarkdownFileLinkMeta | null {
   const candidate = inlineCodeFilePathCandidate(codeText);
   if (candidate === null) return null;
-  const resolved = resolveMarkdownFileLinkMeta(candidate, cwd);
+  const resolved = resolveMarkdownFileLinkMeta(candidate, cwd, baseDir);
   if (resolved) return resolved;
   // `Makefile:12` — conventional extensionless names fail the generic
   // markdown-link candidate patterns, but here the :line suffix already
   // marked the span as a file reference.
-  if (cwd && isConventionalFilePosition(candidate)) {
+  if (baseDir && isConventionalFilePosition(candidate)) {
-    return buildFileLinkMetaFromTarget(resolvePathLinkTarget(candidate, cwd), cwd);
+    return buildFileLinkMetaFromTarget(resolvePathLinkTarget(candidate, baseDir), cwd);
   }
   return null;
 }
 export function resolveMarkdownFileLinkMeta(
   href: string | undefined,
   cwd?: string,
+  baseDir: string | undefined = cwd,
 ): MarkdownFileLinkMeta | null {
-  const targetPath = resolveMarkdownFileLinkTarget(href, cwd);
+  const targetPath = resolveMarkdownFileLinkTarget(href, cwd, baseDir);
   if (!targetPath) return null;
   return buildFileLinkMetaFromTarget(targetPath, cwd);
 }

apps/web/src/rightPanelStore.ts+1−0

@@ -41,6 +41,7 @@ export type RightPanelSurface = · 40 unmodified lines
41	\| {	41	\| {
42	id: `file:${string}`;	42	id: `file:${string}`;
43	kind: "file";	43	kind: "file";
		44	/** Workspace-relative, or absolute for a host file outside the workspace. */
44	relativePath: string;	45	relativePath: string;
45	revealLine: number \| null;	46	revealLine: number \| null;
46	revealRequestId: number;	47	revealRequestId: number;

apps/web/src/terminal-links.ts+1−1

@@ -102,7 +102,7 @@ function isWindowsAbsolutePath(value: string): boolean { · 101 unmodified lines
102	return /^[A-Za-z]:[\\/]/.test(value) \|\| value.startsWith("\\\\");	102	return /^[A-Za-z]:[\\/]/.test(value) \|\| value.startsWith("\\\\");
103	}	103	}
104		104
105	function isAbsolutePath(value: string): boolean {	105	export function isAbsolutePath(value: string): boolean {
106	return value.startsWith("/") \|\| isWindowsAbsolutePath(value);	106	return value.startsWith("/") \|\| isWindowsAbsolutePath(value);
107	}	107	}
108		108

docs/internals/environment-auth.md+16−7

@@ -28,22 +28,31 @@ managed relay connectivity: · 27 unmodified lines
28	The desktop bootstrap credential and command-line administrative bootstrap	28	The desktop bootstrap credential and command-line administrative bootstrap
29	credentials additionally grant `access:read access:write relay:write`.	29	credentials additionally grant `access:read access:write relay:write`.
30		30
		31	## Host file access
		32
		33	Clients with `orchestration:read` can read files anywhere the environment's server account can
		34	read, following the environment-wide authorization model rather than introducing per-project
		35	filesystem permissions. `projects.readFile` accepts an absolute path and returns the text of that
		36	host file; only workspace-relative paths pass its root check, and `projects.writeFile` never
		37	accepts an absolute path. Clients use this to show files an agent wrote outside the workspace, such
		38	as a report in a temp directory, read-only.
		39
31	## Media preview access	40	## Media preview access
32		41
33	Clients with `orchestration:read` can request a `media-file` URL through `assets.createUrl` for	42	Clients with `orchestration:read` can request a `media-file` URL through `assets.createUrl` for
34	supported images and videos anywhere the environment's server account can read. A thread ID	43	supported images, videos, HTML, and PDF files anywhere the environment's server account can read.
35	supplies the workspace for relative paths; absolute paths refer to the environment host, not the	44	A thread ID supplies the workspace for relative paths; absolute paths refer to the environment
36	client. This follows the environment-wide authorization model rather than introducing per-project	45	host, not the client.
37	filesystem permissions.
38		46
39	[`AssetAccess.ts`](../../apps/server/src/assets/AssetAccess.ts) resolves symlinks, requires a regular	47	[`AssetAccess.ts`](../../apps/server/src/assets/AssetAccess.ts) resolves symlinks, requires a regular
40	file, and validates the resolved file's literal extension. It opens the file and signs its canonical	48	file, and validates the resolved file's literal extension. It opens the file and signs its canonical
41	path and device/inode identity for one hour. The token grants access to that exact file, not adjacent	49	path and device/inode identity for one hour. The token grants access to that exact file, not adjacent
42	files or its containing directory. Serving rechecks the canonical path, media type, and opened	50	files or its containing directory. Serving rechecks the canonical path, media type, and opened
43	descriptor's identity, then streams full or partial responses from that descriptor. Replacing a	51	descriptor's identity, then streams full or partial responses from that descriptor. Replacing a
44	file atomically requires a freshly signed URL; editing it in place does not. The existing workspace	52	file atomically requires a freshly signed URL; editing it in place does not. Because the token names
45	boundary still applies to HTML, PDF, and other workspace previews. Uploaded attachments keep their	53	one file, an HTML document served this way cannot load sibling assets; the directory-scoped
46	separate asset resource.	54	`workspace-file` resource remains the route for HTML inside the workspace. Uploaded attachments keep
		55	their separate asset resource.
47		56
48	Signed asset URLs are bearer credentials. Anyone who obtains a URL and can reach the environment	57	Signed asset URLs are bearer credentials. Anyone who obtains a URL and can reach the environment
49	can fetch that file until it expires. Clients should copy the authored reference, not the temporary	58	can fetch that file until it expires. Clients should copy the authored reference, not the temporary

docs/user/composer.md+9−0

@@ -94,6 +94,15 @@ have a cached copy. Supported video formats and codecs depend on the browser or · 93 unmodified lines
94	Bare paths in ordinary prose and paths inside code blocks stay text. Raw HTML `<video>` tags	94	Bare paths in ordinary prose and paths inside code blocks stay text. Raw HTML `<video>` tags
95	are not supported; use the Markdown embed syntax above.	95	are not supported; use the Markdown embed syntax above.
96		96
		97	## Files outside the workspace
		98
		99	When an agent links to a file it wrote outside the workspace, such as a Markdown report in
		100	`/tmp`, select the link to open it in the file viewer. The viewer shows the file read-only, with
		101	rendered Markdown available as usual; it cannot edit files outside the workspace. HTML and PDF
		102	files outside the workspace open the same way as ones inside it, including the integrated browser
		103	where it is available. Because such a file is served on its own, an HTML page outside the workspace
		104	cannot load scripts, styles, or images from files beside it.
		105
97	## Changing projects	106	## Changing projects
98		107
99	On web and desktop, changing the project from a new thread keeps the current environment when that	108	On web and desktop, changing the project from a new thread keeps the current environment when that

packages/contracts/src/assets.ts+4−1

     threadId: ThreadId,
     path: TrimmedNonEmptyString.check(Schema.isMaxLength(ASSET_PATH_MAX_LENGTH)),
   }),
+  // One file served in place from anywhere the environment host can read:
+  // images, videos, HTML, and PDF. An absolute path may lie outside the
+  // workspace; a relative one resolves against the thread's workspace.
   Schema.TaggedStruct("media-file", {
     threadId: ThreadId,
     path: TrimmedNonEmptyString.check(Schema.isMaxLength(ASSET_PATH_MAX_LENGTH)),
 ) {
   override get message(): string {
     return this.resource._tag === "media-file"
-      ? "Only images and videos can be previewed."
+      ? "Only images, videos, HTML, and PDF files can be previewed."
       : "Only browser documents and images can be previewed.";
   }
 }

packages/contracts/src/project.ts+2−0

@@ -193,6 +193,8 @@ export class ProjectListEntriesError extends Schema.TaggedErrorClass<ProjectList · 192 unmodified lines
193		193
194	export const ProjectReadFileInput = Schema.Struct({	194	export const ProjectReadFileInput = Schema.Struct({
195	cwd: TrimmedNonEmptyString,	195	cwd: TrimmedNonEmptyString,
		196	// Workspace-relative, or an absolute host path for a file outside the
		197	// workspace. Only workspace-relative paths can be written back.
196	relativePath: TrimmedNonEmptyString.check(Schema.isMaxLength(PROJECT_READ_FILE_PATH_MAX_LENGTH)),	198	relativePath: TrimmedNonEmptyString.check(Schema.isMaxLength(PROJECT_READ_FILE_PATH_MAX_LENGTH)),
197	});	199	});
198	export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;	200	export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;

packages/shared/src/filePreview.ts+16−0

@@ -24,6 +24,12 @@ const IMAGE_MIME_TYPE_BY_EXTENSION = new Map([ · 23 unmodified lines
24	[".webp", "image/webp"],	24	[".webp", "image/webp"],
25	]);	25	]);
26		26
		27	const BROWSER_MIME_TYPE_BY_EXTENSION = new Map([
		28	[".htm", "text/html"],
		29	[".html", "text/html"],
		30	[".pdf", "application/pdf"],
		31	]);
		32
27	/** Classifies a literal filesystem extension, without URL decoding or suffix removal. */	33	/** Classifies a literal filesystem extension, without URL decoding or suffix removal. */
28	export function mediaMimeTypeFromExtension(extension: string): string \| null {	34	export function mediaMimeTypeFromExtension(extension: string): string \| null {
29	if (!/^\.[a-z0-9]+$/i.test(extension)) return null;	35	if (!/^\.[a-z0-9]+$/i.test(extension)) return null;
@@ -33,6 +39,16 @@ export function mediaMimeTypeFromExtension(extension: string): string \| null { · 3 unmodified lines
33	);	39	);
34	}	40	}
35		41
		42	/** Files the server serves in place from anywhere on its host: media plus browser documents. */
		43	export function hostPreviewMimeTypeFromExtension(extension: string): string \| null {
		44	if (!/^\.[a-z0-9]+$/i.test(extension)) return null;
		45	return (
		46	mediaMimeTypeFromExtension(extension) ??
		47	BROWSER_MIME_TYPE_BY_EXTENSION.get(extension.toLowerCase()) ??
		48	null
		49	);
		50	}
		51
36	/** Classifies an authored media path or URL. Filesystem validation uses the literal extension. */	52	/** Classifies an authored media path or URL. Filesystem validation uses the literal extension. */
37	export function mediaMimeType(path: string): string \| null {	53	export function mediaMimeType(path: string): string \| null {
38	const trimmed = path.trim();	54	const trimmed = path.trim();