Merge master into fix/terminal-history-scroll

test/routes/file-routes-range.test.ts

@@ -0,0 +1,204 @@
+/**
+ * @fileoverview Range-request coverage for the raw file-serving routes.
+ *
+ * The file viewer points a `<video>` at `GET /api/sessions/:id/file-raw`. That
+ * route used to read the whole file and answer 200 with no `Accept-Ranges`,
+ * which makes a browser treat the media as unseekable: measured against an 18MB
+ * mp4, `video.seekable` was `[0, 0]` and assigning `currentTime` was reverted on
+ * the next tick, so the scrub bar looked dead.
+ *
+ * These tests pin the wire contract that makes seeking work, since none of it is
+ * visible from a plain 200-vs-404 assertion:
+ *   1. `Accept-Ranges: bytes` on the un-ranged response (what tells the browser
+ *      it MAY seek at all),
+ *   2. 206 + `Content-Range` + the sliced body for a range request,
+ *   3. the slice actually coming from a bounded read, not a full-file read that
+ *      is then truncated,
+ *   4. 416 (with `Content-Range: bytes *​/size`) for a range past EOF, rather
+ *      than a silent full-body 200 the media element cannot interpret.
+ *
+ * Uses app.inject() — no real ports.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Readable } from 'node:stream';
+import { createRouteTestHarness, type RouteTestHarness } from './_route-test-utils.js';
+import { registerFileRoutes } from '../../src/web/routes/file-routes.js';
+
+const FILE_BYTES = Buffer.from('0123456789ABCDEFGHIJ'); // 20 bytes, index == value position
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn(async () => Buffer.from('unused')),
+    stat: vi.fn(async () => ({ size: 20, isFile: () => true, isDirectory: () => false, mtimeMs: 1 })),
+    readdir: vi.fn(async () => []),
+  },
+}));
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    realpathSync: vi.fn((p: string) => p),
+    // Honour start/end so a test can tell a real bounded read from a full read.
+    createReadStream: vi.fn((_path: string, opts?: { start?: number; end?: number }) => {
+      const start = opts?.start ?? 0;
+      const end = opts?.end ?? FILE_BYTES.length - 1;
+      return Readable.from([FILE_BYTES.subarray(start, end + 1)]);
+    }),
+  };
+});
+
+vi.mock('../../src/file-stream-manager.js', () => ({
+  fileStreamManager: {
+    createStream: vi.fn(async () => ({ success: true, streamId: 'stream-1' })),
+    closeStream: vi.fn(() => true),
+  },
+}));
+
+import fs from 'node:fs/promises';
+import { createReadStream, realpathSync } from 'node:fs';
+
+const mockedStat = vi.mocked(fs.stat);
+const mockedRealpathSync = vi.mocked(realpathSync);
+const mockedCreateReadStream = vi.mocked(createReadStream);
+
+describe('file-raw range requests', () => {
+  let harness: RouteTestHarness;
+  let sid: string;
+
+  beforeEach(async () => {
+    harness = await createRouteTestHarness(registerFileRoutes);
+    vi.clearAllMocks();
+    mockedRealpathSync.mockImplementation((p: string) => p as never);
+    mockedStat.mockResolvedValue({ size: FILE_BYTES.length, isFile: () => true } as never);
+    mockedCreateReadStream.mockImplementation(
+      (_path: unknown, opts?: unknown) =>
+        Readable.from([
+          FILE_BYTES.subarray(
+            (opts as { start?: number })?.start ?? 0,
+            ((opts as { end?: number })?.end ?? FILE_BYTES.length - 1) + 1
+          ),
+        ]) as never
+    );
+    sid = harness.ctx._sessionId as string;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const rawUrl = (name = 'clip.mp4') => `/api/sessions/${sid}/file-raw?path=${name}`;
+
+  it('advertises Accept-Ranges on an un-ranged response, so the browser knows it may seek', async () => {
+    const res = await harness.app.inject({ method: 'GET', url: rawUrl() });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.headers['accept-ranges']).toBe('bytes');
+    expect(res.headers['content-type']).toBe('video/mp4');
+    expect(res.headers['content-length']).toBe(String(FILE_BYTES.length));
+    expect(res.rawPayload.equals(FILE_BYTES)).toBe(true);
+  });
+
+  it('answers bytes=0- with 206 (Chrome opens every media element this way)', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=0-' },
+    });
+
+    expect(res.statusCode).toBe(206);
+    expect(res.headers['content-range']).toBe(`bytes 0-19/${FILE_BYTES.length}`);
+    expect(res.headers['content-length']).toBe(String(FILE_BYTES.length));
+    expect(res.rawPayload.equals(FILE_BYTES)).toBe(true);
+  });
+
+  it('serves a mid-file slice from a bounded read', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=5-9' },
+    });
+
+    expect(res.statusCode).toBe(206);
+    expect(res.headers['content-range']).toBe('bytes 5-9/20');
+    expect(res.headers['content-length']).toBe('5');
+    expect(res.rawPayload.toString()).toBe('56789');
+    // The read itself must be bounded: a full read that is sliced afterwards
+    // would still pull an 18MB video into memory on every seek.
+    expect(mockedCreateReadStream).toHaveBeenCalledWith(expect.any(String), { start: 5, end: 9 });
+  });
+
+  it('serves a suffix range as the LAST N bytes', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=-4' },
+    });
+
+    expect(res.statusCode).toBe(206);
+    expect(res.headers['content-range']).toBe('bytes 16-19/20');
+    expect(res.rawPayload.toString()).toBe('GHIJ');
+  });
+
+  it('answers a range past EOF with 416 instead of a full-body 200', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=100-200' },
+    });
+
+    expect(res.statusCode).toBe(416);
+    expect(res.headers['content-range']).toBe('bytes */20');
+    expect(JSON.parse(res.body).success).toBe(false);
+  });
+
+  it('ignores a malformed range and serves the whole file', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=abc-def' },
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.rawPayload.equals(FILE_BYTES)).toBe(true);
+  });
+
+  it('keeps the security headers on a partial response', async () => {
+    // 206 bodies go out through reply.hijack(), which bypasses Fastify's own
+    // header write — the nosniff/type headers have to be carried across by hand.
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl(),
+      headers: { range: 'bytes=0-3' },
+    });
+
+    expect(res.statusCode).toBe(206);
+    expect(res.headers['x-content-type-options']).toBe('nosniff');
+    expect(res.headers['content-type']).toBe('video/mp4');
+  });
+
+  it('supports resuming a download (?download=true) as well as inline playback', async () => {
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: `${rawUrl('clip.mp4')}&download=true`,
+      headers: { range: 'bytes=10-14' },
+    });
+
+    expect(res.statusCode).toBe(206);
+    expect(res.headers['content-disposition']).toContain('attachment; filename="clip.mp4"');
+    expect(res.rawPayload.toString()).toBe('ABCDE');
+  });
+
+  it('still refuses files past the raw size cap before looking at Range', async () => {
+    mockedStat.mockResolvedValue({ size: 100 * 1024 * 1024, isFile: () => true } as never);
+
+    const res = await harness.app.inject({
+      method: 'GET',
+      url: rawUrl('huge.mp4'),
+      headers: { range: 'bytes=0-99' },
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+});

test/routes/file-routes.test.ts

@@ -6,6 +6,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Readable } from 'node:stream';
 import { createRouteTestHarness, type RouteTestHarness } from './_route-test-utils.js';
 import { registerFileRoutes } from '../../src/web/routes/file-routes.js';
 import { ApiErrorCode } from '../../src/types.js';
@@ -19,12 +20,15 @@ vi.mock('node:fs/promises', () => ({
   },
 }));
 
-// Mock realpathSync for symlink resolution
+// Mock realpathSync for symlink resolution, plus createReadStream: file-raw
+// STREAMS its body (range support), so an unmocked read would hit the real
+// filesystem and fail with ENOENT rather than serving the fixture bytes.
 vi.mock('node:fs', async (importOriginal) => {
   const actual = await importOriginal<typeof import('node:fs')>();
   return {
     ...actual,
     realpathSync: vi.fn((p: string) => p),
+    createReadStream: vi.fn(() => Readable.from([Buffer.from('fake file bytes')])),
   };
 });
 
@@ -37,13 +41,14 @@ vi.mock('../../src/file-stream-manager.js', () => ({
 }));
 
 import fs from 'node:fs/promises';
-import { realpathSync } from 'node:fs';
+import { createReadStream, realpathSync } from 'node:fs';
 import { fileStreamManager } from '../../src/file-stream-manager.js';
 
 const mockedReaddir = vi.mocked(fs.readdir);
 const mockedReadFile = vi.mocked(fs.readFile);
 const mockedStat = vi.mocked(fs.stat);
 const mockedRealpathSync = vi.mocked(realpathSync);
+const mockedCreateReadStream = vi.mocked(createReadStream);
 const mockedFileStreamManager = vi.mocked(fileStreamManager);
 
 describe('file-routes', () => {
@@ -55,6 +60,7 @@ describe('file-routes', () => {
 
     // Default: realpathSync returns the path unchanged
     mockedRealpathSync.mockImplementation((p: string) => p as never);
+    mockedCreateReadStream.mockImplementation(() => Readable.from([Buffer.from('fake file bytes')]) as never);
     // Default stat
     mockedStat.mockResolvedValue({ size: 100, isFile: () => true, isDirectory: () => true } as never);
     mockedReadFile.mockImplementation(async (path) =>
@@ -739,7 +745,7 @@ describe('file-routes', () => {
 
     it('serves raw file with correct content type', async () => {
       const content = Buffer.from('fake png data');
-      mockedReadFile.mockResolvedValue(content as never);
+      mockedCreateReadStream.mockReturnValue(Readable.from([content]) as never);
       mockedStat.mockResolvedValue({ size: content.length } as never);
 
       const res = await harness.app.inject({
@@ -752,7 +758,7 @@ describe('file-routes', () => {
 
     it('serves workspace SVG as an untrusted attachment instead of inline image/svg+xml', async () => {
       const content = Buffer.from('<svg><script>alert("xss")</script></svg>');
-      mockedReadFile.mockResolvedValue(content as never);
+      mockedCreateReadStream.mockReturnValue(Readable.from([content]) as never);
       mockedStat.mockResolvedValue({ size: content.length } as never);
 
       const res = await harness.app.inject({