mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-11-18 12:19:33 +01:00
Keep the 1.49.0 API meaning: liveWorktree and root=live stay inside the session folder, and an outside worktree is published as outsideWorktree and walked only with root=live-any. Refuse a symlinked .git folder as the main worktree, sensitive files inside a followed worktree, and any outside worktree while attachment confinement is on or around a blocked tree. The file routes re-check the guard settings on every request, and a throwing rule check refuses. The panel keeps its Back to worktree button while pinned to the session folder. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
300 lines
14 KiB
TypeScript
300 lines
14 KiB
TypeScript
/**
|
||
* @fileoverview The file routes for a worktree OUTSIDE the session's folder (#765 follow-up).
|
||
*
|
||
* A session's outside worktree is a second root: `GET .../files?root=live-any` lists it with
|
||
* ABSOLUTE paths (`root=live` keeps walking `workingDir`), and the read, raw, edit and download
|
||
* routes confine an absolute path inside it to it. What must not change: a relative path still resolves against `workingDir` only, a path that
|
||
* escapes the worktree through a symlink is refused, and a worktree folder replaced by a symlink is
|
||
* neither listed nor served. Real filesystem on purpose, since realpath is the thing under test.
|
||
*/
|
||
import { createHash } from 'node:crypto';
|
||
import { mkdirSync, mkdtempSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
|
||
import { readFileSync } from 'node:fs';
|
||
import { tmpdir } from 'node:os';
|
||
import { dirname } from 'node:path';
|
||
import { join } from 'node:path';
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||
import { createRouteTestHarness, type RouteTestHarness } from './_route-test-utils.js';
|
||
import { registerFileRoutes } from '../../src/web/routes/file-routes.js';
|
||
import { SETTINGS_PATH } from '../../src/web/route-helpers.js';
|
||
|
||
// The converter would shell out to pdftoppm/LibreOffice; the route's own path check is under test.
|
||
vi.mock('../../src/document-thumbnailer.js', () => ({
|
||
generateFirstPageThumbnail: vi.fn(async () => ({ content: Buffer.from('\x89PNG fake'), contentType: 'image/png' })),
|
||
}));
|
||
import { generateFirstPageThumbnail } from '../../src/document-thumbnailer.js';
|
||
|
||
const sha256 = (text: string) => createHash('sha256').update(text).digest('hex');
|
||
|
||
describe('file routes for a worktree outside the session folder', () => {
|
||
let harness: RouteTestHarness;
|
||
let base: string;
|
||
let repo: string;
|
||
let sibling: string;
|
||
let secret: string;
|
||
|
||
const sessionUrl = (rest: string) => `/api/sessions/${harness.ctx._sessionId}/${rest}`;
|
||
const list = async (query = '') => {
|
||
const res = await harness.app.inject({ method: 'GET', url: sessionUrl(`files?depth=5${query}`) });
|
||
expect(res.statusCode).toBe(200);
|
||
return res.json().data;
|
||
};
|
||
const readContent = (path: string) =>
|
||
harness.app.inject({ method: 'GET', url: sessionUrl(`file-content?path=${encodeURIComponent(path)}`) });
|
||
|
||
beforeEach(async () => {
|
||
harness = await createRouteTestHarness(registerFileRoutes);
|
||
base = realpathSync(mkdtempSync(join(tmpdir(), 'outside-worktree-route-')));
|
||
repo = join(base, 'myapp');
|
||
sibling = join(base, 'myapp-feature');
|
||
secret = join(base, 'secret');
|
||
mkdirSync(join(repo, 'src'), { recursive: true });
|
||
mkdirSync(join(sibling, 'src'), { recursive: true });
|
||
mkdirSync(secret);
|
||
writeFileSync(join(repo, 'src', 'main-only.ts'), 'main');
|
||
writeFileSync(join(sibling, 'src', 'feature-only.ts'), 'feature');
|
||
writeFileSync(join(secret, 'key.txt'), 'secret');
|
||
Object.assign(harness.ctx._session, {
|
||
workingDir: repo,
|
||
liveWorktree: { name: 'myapp-feature', path: sibling, outside: true },
|
||
});
|
||
});
|
||
|
||
afterEach(async () => {
|
||
await harness.app.close();
|
||
rmSync(base, { recursive: true, force: true });
|
||
rmSync(SETTINGS_PATH, { force: true });
|
||
});
|
||
|
||
describe('GET .../files', () => {
|
||
it('lists the worktree with absolute paths', async () => {
|
||
const data = await list('&root=live-any');
|
||
expect(data.root).toBe(sibling);
|
||
expect(data.worktree).toEqual({ name: 'myapp-feature', path: sibling, outside: true });
|
||
expect(data.tree[0].path).toBe(join(sibling, 'src'));
|
||
expect(data.tree[0].children[0].path).toBe(join(sibling, 'src', 'feature-only.ts'));
|
||
});
|
||
|
||
it('searches the worktree, matching on paths relative to it and answering absolute ones', async () => {
|
||
const data = await list(`&root=live-any&q=${encodeURIComponent('src/feature*')}`);
|
||
expect(data.matches.map((m: { path: string }) => m.path)).toEqual([join(sibling, 'src', 'feature-only.ts')]);
|
||
});
|
||
|
||
it('keeps walking the session folder, with relative paths, for root=live', async () => {
|
||
const data = await list('&root=live');
|
||
expect(data.root).toBe(repo);
|
||
expect(data.worktree).toBeUndefined();
|
||
expect(data.tree[0].children[0].path).toBe('src/main-only.ts');
|
||
expect(JSON.stringify(data.tree)).not.toContain('feature-only.ts');
|
||
});
|
||
|
||
it('keeps the session folder, with relative paths, without the parameter', async () => {
|
||
const data = await list();
|
||
expect(data.root).toBe(repo);
|
||
expect(data.worktree).toBeUndefined();
|
||
expect(data.tree[0].children[0].path).toBe('src/main-only.ts');
|
||
});
|
||
|
||
it('falls back to the session folder once a symlink has taken the worktree folder’s place', async () => {
|
||
renameSync(sibling, `${sibling}-moved`);
|
||
symlinkSync(secret, sibling);
|
||
const data = await list('&root=live-any');
|
||
expect(data.root).toBe(repo);
|
||
expect(JSON.stringify(data.tree)).not.toContain('key.txt');
|
||
});
|
||
});
|
||
|
||
describe('GET .../file-content', () => {
|
||
it('serves an absolute path inside the worktree', async () => {
|
||
const res = await readContent(join(sibling, 'src', 'feature-only.ts'));
|
||
expect(res.statusCode).toBe(200);
|
||
expect(JSON.stringify(res.json())).toContain('feature');
|
||
});
|
||
|
||
it('refuses a sensitive file in the worktree on file-content and file-raw, and serves its neighbours', async () => {
|
||
writeFileSync(join(sibling, '.env'), 'TOKEN=abc');
|
||
mkdirSync(join(sibling, '.aws'));
|
||
writeFileSync(join(sibling, '.aws', 'credentials'), 'aws_secret=abc');
|
||
writeFileSync(join(sibling, 'plain.ts'), 'plain');
|
||
for (const blocked of [join(sibling, '.env'), join(sibling, '.aws', 'credentials')]) {
|
||
const content = await readContent(blocked);
|
||
expect(content.json().success).toBe(false);
|
||
expect(content.body).not.toContain('abc');
|
||
const raw = await harness.app.inject({
|
||
method: 'GET',
|
||
url: sessionUrl(`file-raw?path=${encodeURIComponent(blocked)}`),
|
||
});
|
||
expect(raw.statusCode).not.toBe(200);
|
||
expect(raw.body).not.toContain('abc');
|
||
}
|
||
const plain = await readContent(join(sibling, 'plain.ts'));
|
||
expect(plain.json().success).toBe(true);
|
||
const plainRaw = await harness.app.inject({
|
||
method: 'GET',
|
||
url: sessionUrl(`file-raw?path=${encodeURIComponent(join(sibling, 'plain.ts'))}`),
|
||
});
|
||
expect(plainRaw.statusCode).toBe(200);
|
||
expect(plainRaw.body).toBe('plain');
|
||
});
|
||
|
||
it('still resolves a relative path against the session folder only', async () => {
|
||
expect((await readContent('src/main-only.ts')).statusCode).toBe(200);
|
||
const escaped = await readContent('../myapp-feature/src/feature-only.ts');
|
||
expect(JSON.stringify(escaped.json())).not.toContain('"feature"');
|
||
expect(escaped.json().success).toBe(false);
|
||
});
|
||
|
||
it('refuses a symlink in the worktree that leads out of it', async () => {
|
||
symlinkSync(join(secret, 'key.txt'), join(sibling, 'leak.txt'));
|
||
const res = await readContent(join(sibling, 'leak.txt'));
|
||
expect(res.json().success).toBe(false);
|
||
expect(JSON.stringify(res.json())).not.toContain('"secret"');
|
||
});
|
||
|
||
it('serves a symlink in the worktree that leads into the session folder', async () => {
|
||
symlinkSync(join(repo, 'src', 'main-only.ts'), join(sibling, 'main-link.ts'));
|
||
const res = await readContent(join(sibling, 'main-link.ts'));
|
||
expect(res.statusCode).toBe(200);
|
||
expect(res.json().success).toBe(true);
|
||
});
|
||
|
||
it('serves nothing from the folder once a symlink has taken its place', async () => {
|
||
renameSync(sibling, `${sibling}-moved`);
|
||
symlinkSync(secret, sibling);
|
||
const res = await readContent(join(sibling, 'key.txt'));
|
||
expect(res.json().success).toBe(false);
|
||
});
|
||
|
||
it('serves nothing outside the session folder once the worktree is not outside', async () => {
|
||
Object.assign(harness.ctx._session, { liveWorktree: { name: 'myapp-feature', path: sibling } });
|
||
const res = await readContent(join(sibling, 'src', 'feature-only.ts'));
|
||
expect(res.json().success).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe('file-raw, download and edit', () => {
|
||
it('streams an absolute path inside the worktree from file-raw and download', async () => {
|
||
const target = join(sibling, 'src', 'feature-only.ts');
|
||
const raw = await harness.app.inject({
|
||
method: 'GET',
|
||
url: sessionUrl(`file-raw?path=${encodeURIComponent(target)}`),
|
||
});
|
||
expect(raw.statusCode).toBe(200);
|
||
expect(raw.body).toBe('feature');
|
||
const download = await harness.app.inject({
|
||
method: 'GET',
|
||
url: `/api/download?sessionId=${harness.ctx._sessionId}&path=${encodeURIComponent(target)}`,
|
||
});
|
||
expect(download.statusCode).toBe(200);
|
||
expect(download.body).toBe('feature');
|
||
});
|
||
|
||
it('edits a file inside the worktree in place', async () => {
|
||
const target = join(sibling, 'notes.md');
|
||
writeFileSync(target, 'before\n');
|
||
const res = await harness.app.inject({
|
||
method: 'PUT',
|
||
url: sessionUrl('file-content'),
|
||
payload: { path: target, content: 'after\n', baseHash: sha256('before\n') },
|
||
});
|
||
expect(res.statusCode).toBe(200);
|
||
expect(readFileSync(target, 'utf8')).toBe('after\n');
|
||
});
|
||
|
||
it('refuses to edit through a symlink that leads out of the worktree', async () => {
|
||
symlinkSync(join(secret, 'key.txt'), join(sibling, 'leak.md'));
|
||
const res = await harness.app.inject({
|
||
method: 'PUT',
|
||
url: sessionUrl('file-content'),
|
||
payload: { path: join(sibling, 'leak.md'), content: 'pwned', baseHash: sha256('secret') },
|
||
});
|
||
expect(res.statusCode).toBe(404);
|
||
expect(readFileSync(join(secret, 'key.txt'), 'utf8')).toBe('secret');
|
||
});
|
||
});
|
||
|
||
describe('file-preview and file-thumbnail', () => {
|
||
const preview = (path: string) =>
|
||
harness.app.inject({ method: 'GET', url: sessionUrl(`file-preview?path=${encodeURIComponent(path)}`) });
|
||
const thumbnail = (path: string) =>
|
||
harness.app.inject({ method: 'GET', url: sessionUrl(`file-thumbnail?path=${encodeURIComponent(path)}`) });
|
||
|
||
beforeEach(() => {
|
||
vi.mocked(generateFirstPageThumbnail).mockClear();
|
||
writeFileSync(join(sibling, 'doc.pdf'), '%PDF-1.4 fake');
|
||
writeFileSync(join(sibling, 'pic.png'), 'png');
|
||
});
|
||
|
||
it('answers file-preview for an absolute path inside the worktree', async () => {
|
||
const res = await preview(join(sibling, 'doc.pdf'));
|
||
expect(res.statusCode).toBeGreaterThanOrEqual(300);
|
||
expect(res.statusCode).toBeLessThan(400);
|
||
expect(res.headers.location).toContain('/file-raw?path=');
|
||
});
|
||
|
||
it('serves file-thumbnail for an absolute path inside the worktree', async () => {
|
||
const res = await thumbnail(join(sibling, 'pic.png'));
|
||
expect(res.statusCode).toBe(200);
|
||
expect(res.headers['content-type']).toContain('image/png');
|
||
expect(generateFirstPageThumbnail).toHaveBeenCalled();
|
||
});
|
||
|
||
it('refuses both once a symlink has taken the worktree folder’s place', async () => {
|
||
writeFileSync(join(secret, 'doc.pdf'), '%PDF-1.4 fake');
|
||
writeFileSync(join(secret, 'pic.png'), 'png');
|
||
renameSync(sibling, `${sibling}-moved`);
|
||
symlinkSync(secret, sibling);
|
||
expect((await preview(join(sibling, 'doc.pdf'))).statusCode).toBe(404);
|
||
expect((await thumbnail(join(sibling, 'pic.png'))).statusCode).toBe(404);
|
||
expect(generateFirstPageThumbnail).not.toHaveBeenCalled();
|
||
});
|
||
});
|
||
describe('the attachment guard, judged again on every request', () => {
|
||
const target = () => join(sibling, 'src', 'feature-only.ts');
|
||
const writeSettings = (settings: Record<string, unknown>) => {
|
||
mkdirSync(dirname(SETTINGS_PATH), { recursive: true });
|
||
writeFileSync(SETTINGS_PATH, JSON.stringify(settings));
|
||
};
|
||
const get = (route: string) =>
|
||
harness.app.inject({ method: 'GET', url: sessionUrl(`${route}?path=${encodeURIComponent(target())}`) });
|
||
|
||
it('serves the worktree while no guard rule applies', async () => {
|
||
writeSettings({});
|
||
expect((await get('file-raw')).statusCode).toBe(200);
|
||
});
|
||
|
||
it.each([
|
||
['workspace confinement is turned on', () => ({ attachmentConfineToWorkspace: true })],
|
||
['the worktree’s parent folder is blocked', () => ({ attachmentBlockedPaths: [base] })],
|
||
])('stops serving it once %s', async (_label, settings) => {
|
||
writeSettings(settings());
|
||
|
||
const content = await get('file-content');
|
||
expect(content.json().success).toBe(false);
|
||
expect(content.body).not.toContain('feature');
|
||
expect((await get('file-raw')).statusCode).toBe(404);
|
||
|
||
const before = readFileSync(target(), 'utf8');
|
||
const put = await harness.app.inject({
|
||
method: 'PUT',
|
||
url: sessionUrl('file-content'),
|
||
payload: { path: target(), content: 'changed', baseHash: sha256(before) },
|
||
});
|
||
expect(put.statusCode).toBe(404);
|
||
expect(readFileSync(target(), 'utf8')).toBe(before);
|
||
|
||
const download = await harness.app.inject({
|
||
method: 'GET',
|
||
url: `/api/download?sessionId=${harness.ctx._sessionId}&path=${encodeURIComponent(target())}`,
|
||
});
|
||
expect(download.statusCode).toBe(404);
|
||
|
||
// The listing walks the session folder, and keeps reporting the worktree so the panel settles.
|
||
const data = await list('&root=live-any');
|
||
expect(data.root).toBe(repo);
|
||
expect(data.tree[0].children[0].path).toBe('src/main-only.ts');
|
||
expect(data.worktree).toEqual({ name: 'myapp-feature', path: sibling, outside: true });
|
||
});
|
||
});
|
||
});
|