mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-11-20 04:59:34 +01:00
The owner of a managed dsh tab is compared with the server's starter only in multi-user mode: a record created there keeps its owner, while a single-user start records none, so that tab would never get its cookie again (new route test). CLAUDE.md and the invariants doc name the cookie rules. The third item, Codeman's session cookie filtered on the WebSocket leg whether or not the dsh cookie is injected, came in with the merge itself, where it met #827. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
685 lines
29 KiB
TypeScript
685 lines
29 KiB
TypeScript
/**
|
|
* CRUD + capability behaviour for /api/webviews.
|
|
*
|
|
* Uses app.inject() (no port) against a temp CODEMAN_DATA_DIR, so nothing touches
|
|
* the developer's real ~/.codeman/webviews.json.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
|
import Fastify, { type FastifyInstance } from 'fastify';
|
|
import fastifyCookie from '@fastify/cookie';
|
|
import fastifyWebsocket from '@fastify/websocket';
|
|
import WebSocket, { WebSocketServer } from 'ws';
|
|
import { once } from 'node:events';
|
|
import type { AddressInfo } from 'node:net';
|
|
import fs from 'node:fs/promises';
|
|
import http, { createServer, type IncomingHttpHeaders, type Server } from 'node:http';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { registerWebviewRoutes } from '../../src/web/routes/webview-routes.js';
|
|
import { installRouteErrorHandler } from '../../src/web/route-error-handler.js';
|
|
import { webviewCapabilities } from '../../src/webview-capabilities.js';
|
|
import { capabilityFromProxyPath } from '../../src/web/webview-proxy.js';
|
|
import { writeWebviews } from '../../src/webview-store.js';
|
|
import { readUsers } from '../../src/user-store.js';
|
|
import { TabLayoutService } from '../../src/tab-layout-service.js';
|
|
import type { TabLayout } from '../../src/tab-layout.js';
|
|
|
|
/**
|
|
* The supervisor is the one process-spawning piece in this path. Its own tests
|
|
* cover the launch-token exchange and the starter binding; here a stub stands in
|
|
* for "this port has a cookie" so the route-level question stays what the proxy
|
|
* actually puts on the upstream request.
|
|
*/
|
|
const { getDeepSeekWebCookie } = vi.hoisted(() => ({
|
|
getDeepSeekWebCookie: vi.fn((_port: number, _owner?: string): string | null => null),
|
|
}));
|
|
|
|
vi.mock('../../src/deepseek-web-server.js', () => ({ getDeepSeekWebCookie }));
|
|
|
|
let app: FastifyInstance;
|
|
let tmpDir: string;
|
|
let savedDataDir: string | undefined;
|
|
let savedMultiUser: string | undefined;
|
|
/** Stands in for what the auth middleware decorates on the request. */
|
|
let currentUser: { username: string; role: 'admin' | 'user' } | undefined;
|
|
const broadcasts: Array<{ event: string; data: unknown }> = [];
|
|
const webviewCreated = vi.fn(async () => {});
|
|
const webviewDeleted = vi.fn(async () => {});
|
|
|
|
beforeEach(async () => {
|
|
tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codeman-webviews-'));
|
|
savedDataDir = process.env.CODEMAN_DATA_DIR;
|
|
savedMultiUser = process.env.CODEMAN_MULTIUSER;
|
|
process.env.CODEMAN_DATA_DIR = tmpDir;
|
|
delete process.env.CODEMAN_MULTIUSER;
|
|
currentUser = undefined;
|
|
broadcasts.length = 0;
|
|
webviewCreated.mockClear();
|
|
webviewDeleted.mockClear();
|
|
getDeepSeekWebCookie.mockReset();
|
|
getDeepSeekWebCookie.mockReturnValue(null);
|
|
|
|
app = Fastify({ logger: false });
|
|
await app.register(fastifyCookie);
|
|
// The proxy route declares a wsHandler, so the plugin must be present.
|
|
await app.register(fastifyWebsocket);
|
|
app.addHook('onRequest', async (req) => {
|
|
if (currentUser) (req as unknown as { authUser: typeof currentUser }).authUser = currentUser;
|
|
});
|
|
registerWebviewRoutes(app, {
|
|
broadcast: (event: string, data: unknown) => broadcasts.push({ event, data }),
|
|
tabLayouts: { webviewCreated, webviewDeleted },
|
|
} as never);
|
|
installRouteErrorHandler(app);
|
|
await app.ready();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await app.close();
|
|
if (savedDataDir === undefined) delete process.env.CODEMAN_DATA_DIR;
|
|
else process.env.CODEMAN_DATA_DIR = savedDataDir;
|
|
if (savedMultiUser === undefined) delete process.env.CODEMAN_MULTIUSER;
|
|
else process.env.CODEMAN_MULTIUSER = savedMultiUser;
|
|
await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
|
|
});
|
|
|
|
const create = (payload: Record<string, unknown>) => app.inject({ method: 'POST', url: '/api/webviews', payload });
|
|
|
|
/** Wait for something a relayed connection reports asynchronously. */
|
|
async function waitUntil(check: () => boolean, timeoutMs = 2000): Promise<void> {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (!check()) {
|
|
if (Date.now() > deadline) throw new Error('condition not met in time');
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
}
|
|
}
|
|
|
|
describe('GET /api/webviews', () => {
|
|
it('starts empty and reports the frame budget the client must honour', async () => {
|
|
const res = await app.inject({ method: 'GET', url: '/api/webviews' });
|
|
expect(res.statusCode).toBe(200);
|
|
const body = res.json();
|
|
expect(body.success).toBe(true);
|
|
expect(body.data.webviews).toEqual([]);
|
|
expect(typeof body.data.maxLiveFrames).toBe('number');
|
|
});
|
|
});
|
|
|
|
describe('POST /api/webviews', () => {
|
|
it('creates a dashboard that defaults to proxied and sandboxed', async () => {
|
|
const res = await create({ name: 'Grafana', url: 'http://127.0.0.1:4000/' });
|
|
expect(res.statusCode).toBe(200);
|
|
const w = res.json().data;
|
|
// Proxy + untrusted are the safe defaults and must not drift.
|
|
expect(w.embedMode).toBe('proxy');
|
|
expect(w.trusted).toBe(false);
|
|
expect(w.id).toBeTruthy();
|
|
});
|
|
|
|
it('broadcasts the change so other devices re-fetch', async () => {
|
|
await create({ name: 'G', url: 'http://127.0.0.1:4000/' });
|
|
expect(broadcasts.map((b) => b.event)).toContain('webview:changed');
|
|
});
|
|
|
|
it('persists across a fresh read of the store', async () => {
|
|
await create({ name: 'G', url: 'http://127.0.0.1:4000/' });
|
|
const list = (await app.inject({ method: 'GET', url: '/api/webviews' })).json().data.webviews;
|
|
expect(list).toHaveLength(1);
|
|
expect(list[0].name).toBe('G');
|
|
});
|
|
|
|
it('rejects URLs that are not plain http(s)', async () => {
|
|
for (const url of ['javascript:alert(1)', 'file:///etc/passwd', 'data:text/html,x']) {
|
|
const res = await create({ name: 'bad', url });
|
|
expect(res.statusCode, url).toBe(400);
|
|
expect(res.json().errorCode).toBe('INVALID_INPUT');
|
|
}
|
|
});
|
|
|
|
it('rolls back webview persistence and emits nothing when layout capacity rejects insertion', async () => {
|
|
const refs = Array.from({ length: 512 }, (_, index) => ({ kind: 'session' as const, id: `s-${index}` }));
|
|
const original: TabLayout = {
|
|
version: 9,
|
|
groups: [],
|
|
ungrouped: refs,
|
|
updatedAt: '2026-08-16T00:00:00.000Z',
|
|
};
|
|
let stored = original;
|
|
const live = new Map(refs.map((ref, index) => [ref.id, { id: ref.id, createdAt: index }]));
|
|
const atomicBroadcast = vi.fn();
|
|
const service = new TabLayoutService({
|
|
store: {
|
|
getTabLayout: () => stored,
|
|
setTabLayout: (_owner, layout) => {
|
|
stored = layout;
|
|
},
|
|
getSessions: () => ({}),
|
|
getSessionOrder: () => [],
|
|
} as never,
|
|
sessions: live,
|
|
readWebviews: async () =>
|
|
(await import('../../src/webview-store.js')).readWebviews(tmpDir) as Promise<
|
|
Array<{ id: string; owner?: string }>
|
|
>,
|
|
broadcast: atomicBroadcast,
|
|
broadcastSessionOrder: vi.fn(),
|
|
});
|
|
const atomicApp = Fastify({ logger: false });
|
|
await atomicApp.register(fastifyCookie);
|
|
await atomicApp.register(fastifyWebsocket);
|
|
registerWebviewRoutes(atomicApp, {
|
|
broadcast: atomicBroadcast,
|
|
tabLayouts: service,
|
|
} as never);
|
|
installRouteErrorHandler(atomicApp);
|
|
await atomicApp.ready();
|
|
|
|
const response = await atomicApp.inject({
|
|
method: 'POST',
|
|
url: '/api/webviews',
|
|
payload: { name: 'overflow', url: 'https://example.test/' },
|
|
});
|
|
const list = (await atomicApp.inject({ method: 'GET', url: '/api/webviews' })).json().data.webviews;
|
|
|
|
expect(response.statusCode).toBe(500);
|
|
expect(list).toEqual([]);
|
|
expect(stored).toEqual(original);
|
|
expect(atomicBroadcast).not.toHaveBeenCalled();
|
|
await atomicApp.close();
|
|
});
|
|
|
|
it('rejects URLs carrying embedded credentials', async () => {
|
|
const res = await create({ name: 'bad', url: 'http://user:pass@host:4000/' });
|
|
expect(res.statusCode).toBe(400);
|
|
});
|
|
|
|
it('requires a name', async () => {
|
|
expect((await create({ url: 'http://127.0.0.1:4000/' })).statusCode).toBe(400);
|
|
expect((await create({ name: ' ', url: 'http://127.0.0.1:4000/' })).statusCode).toBe(400);
|
|
});
|
|
});
|
|
|
|
describe('PATCH /api/webviews/:id', () => {
|
|
it('updates fields and revokes the outstanding capability', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
const opened = await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` });
|
|
const cap = capabilityFromProxyPath(opened.json().data.embedUrl)!;
|
|
expect(webviewCapabilities.resolve(cap)).toBeDefined();
|
|
|
|
const res = await app.inject({
|
|
method: 'PATCH',
|
|
url: `/api/webviews/${id}`,
|
|
payload: { url: 'http://127.0.0.1:4001/' },
|
|
});
|
|
expect(res.statusCode).toBe(200);
|
|
expect(res.json().data.url).toBe('http://127.0.0.1:4001/');
|
|
// A token minted against the OLD url must not survive the repoint.
|
|
expect(webviewCapabilities.resolve(cap)).toBeUndefined();
|
|
});
|
|
|
|
it('404s an unknown id', async () => {
|
|
const res = await app.inject({ method: 'PATCH', url: '/api/webviews/nope', payload: { name: 'x' } });
|
|
expect(res.statusCode).toBe(404);
|
|
});
|
|
|
|
it('still validates the URL on update', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
const res = await app.inject({ method: 'PATCH', url: `/api/webviews/${id}`, payload: { url: 'file:///etc' } });
|
|
expect(res.statusCode).toBe(400);
|
|
});
|
|
});
|
|
|
|
describe('DELETE /api/webviews/:id', () => {
|
|
it('removes it and revokes its capability', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
const opened = await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` });
|
|
const cap = capabilityFromProxyPath(opened.json().data.embedUrl)!;
|
|
|
|
expect((await app.inject({ method: 'DELETE', url: `/api/webviews/${id}` })).statusCode).toBe(200);
|
|
expect((await app.inject({ method: 'GET', url: '/api/webviews' })).json().data.webviews).toEqual([]);
|
|
expect(webviewCapabilities.resolve(cap)).toBeUndefined();
|
|
});
|
|
|
|
it('keeps the exact saved record and emits nothing when layout deletion fails', async () => {
|
|
const created = (await create({ name: 'Keep me', url: 'https://keep.example/' })).json().data;
|
|
broadcasts.length = 0;
|
|
webviewDeleted.mockRejectedValueOnce(new Error('tab layout restoration failed'));
|
|
|
|
const response = await app.inject({ method: 'DELETE', url: `/api/webviews/${created.id}` });
|
|
const list = (await app.inject({ method: 'GET', url: '/api/webviews' })).json().data.webviews;
|
|
|
|
expect(response.statusCode).toBe(500);
|
|
expect(list).toEqual([created]);
|
|
expect(broadcasts).toEqual([]);
|
|
});
|
|
|
|
it('404s an unknown id', async () => {
|
|
expect((await app.inject({ method: 'DELETE', url: '/api/webviews/nope' })).statusCode).toBe(404);
|
|
});
|
|
});
|
|
|
|
describe('POST /api/webviews/:id/open', () => {
|
|
it('mints a same-origin embed path for a proxied dashboard', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
const data = (await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` })).json().data;
|
|
expect(data.embedUrl).toMatch(/^\/webview\/[A-Za-z0-9_-]{16,}\/$/);
|
|
expect(capabilityFromProxyPath(data.embedUrl)).toBeTruthy();
|
|
});
|
|
|
|
it('returns no embed path in direct mode, where the iframe uses the real URL', async () => {
|
|
const id = (await create({ name: 'G', url: 'https://ok.example/', embedMode: 'direct' })).json().data.id;
|
|
const data = (await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` })).json().data;
|
|
expect(data.embedUrl).toBeUndefined();
|
|
expect(data.webview.url).toBe('https://ok.example/');
|
|
});
|
|
|
|
it('reuses the capability across repeated opens instead of leaking one per click', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
const first = (await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` })).json().data.embedUrl;
|
|
const second = (await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` })).json().data.embedUrl;
|
|
expect(second).toBe(first);
|
|
});
|
|
|
|
it('records lastOpenedAt', async () => {
|
|
const id = (await create({ name: 'G', url: 'http://127.0.0.1:4000/' })).json().data.id;
|
|
await app.inject({ method: 'POST', url: `/api/webviews/${id}/open` });
|
|
const list = (await app.inject({ method: 'GET', url: '/api/webviews' })).json().data.webviews;
|
|
expect(typeof list[0].lastOpenedAt).toBe('number');
|
|
});
|
|
|
|
it('404s an unknown id', async () => {
|
|
expect((await app.inject({ method: 'POST', url: '/api/webviews/nope/open' })).statusCode).toBe(404);
|
|
});
|
|
});
|
|
|
|
describe('proxy route', () => {
|
|
it('refuses an unknown or expired capability', async () => {
|
|
const res = await app.inject({ method: 'GET', url: `/webview/${'Z'.repeat(32)}/` });
|
|
expect(res.statusCode).toBe(403);
|
|
});
|
|
|
|
it('redirects the prefix without a trailing slash, so relative URLs resolve inside it', async () => {
|
|
const cap = 'Y'.repeat(32);
|
|
const res = await app.inject({ method: 'GET', url: `/webview/${cap}` });
|
|
expect(res.statusCode).toBe(302);
|
|
expect(res.headers.location).toBe(`/webview/${cap}/`);
|
|
});
|
|
});
|
|
|
|
describe('proxy route: WebSocket cookie forwarding', () => {
|
|
let upstream: Server;
|
|
let upstreamPort: number;
|
|
let wss: WebSocketServer;
|
|
let appPort: number;
|
|
let upgradeHeaders: Promise<IncomingHttpHeaders>;
|
|
let client: WebSocket | undefined;
|
|
|
|
beforeEach(async () => {
|
|
let resolveUpgrade!: (headers: IncomingHttpHeaders) => void;
|
|
upgradeHeaders = new Promise((resolve) => {
|
|
resolveUpgrade = resolve;
|
|
});
|
|
|
|
// A real loopback dashboard: its upgrade handler is what records the cookie
|
|
// the proxy put on the handshake.
|
|
upstream = createServer();
|
|
wss = new WebSocketServer({ noServer: true });
|
|
upstream.on('upgrade', (req, socket, head) => {
|
|
resolveUpgrade(req.headers);
|
|
wss.handleUpgrade(req, socket, head, (upstreamSocket) => {
|
|
wss.emit('connection', upstreamSocket, req);
|
|
});
|
|
});
|
|
await new Promise<void>((resolve) => upstream.listen(0, '127.0.0.1', resolve));
|
|
upstreamPort = (upstream.address() as AddressInfo).port;
|
|
|
|
// WebSocket upgrades cannot go through inject(); this app needs a real port.
|
|
await app.listen({ port: 0, host: '127.0.0.1' });
|
|
appPort = (app.server.address() as AddressInfo).port;
|
|
});
|
|
|
|
afterEach(async () => {
|
|
client?.terminate();
|
|
client = undefined;
|
|
for (const socket of wss.clients) socket.terminate();
|
|
await new Promise<void>((resolve) => wss.close(() => resolve()));
|
|
await new Promise<void>((resolve) => upstream.close(() => resolve()));
|
|
await app.close();
|
|
});
|
|
|
|
/** Wait for a promise without letting a missing handshake hang the test until vitest's timeout. */
|
|
function within<T>(promise: Promise<T>, timeoutMs = 5000): Promise<T> {
|
|
let timer!: NodeJS.Timeout;
|
|
const timeout = new Promise<never>((_, reject) => {
|
|
timer = setTimeout(() => reject(new Error('timed out waiting for the upstream WebSocket handshake')), timeoutMs);
|
|
});
|
|
return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
|
|
}
|
|
|
|
/** Create a trusted tab, open it for a capability, and connect the browser leg with `cookie`. */
|
|
async function connectThroughProxy(cookie: string): Promise<void> {
|
|
const created = await create({
|
|
name: 'Trusted dashboard',
|
|
url: `http://127.0.0.1:${upstreamPort}/`,
|
|
trusted: true,
|
|
});
|
|
expect(created.statusCode).toBe(200);
|
|
const opened = await app.inject({ method: 'POST', url: `/api/webviews/${created.json().data.id}/open` });
|
|
const cap = capabilityFromProxyPath(opened.json().data.embedUrl)!;
|
|
|
|
client = await new Promise<WebSocket>((resolve, reject) => {
|
|
const socket = new WebSocket(`ws://127.0.0.1:${appPort}/webview/${cap}/ws`, { headers: { cookie } });
|
|
socket.once('open', () => resolve(socket));
|
|
socket.once('error', reject);
|
|
});
|
|
}
|
|
|
|
it('forwards only the dashboard cookie, never the Codeman session cookie', async () => {
|
|
await connectThroughProxy('codeman_session=SECRET; theme=dark');
|
|
|
|
const headers = await within(upgradeHeaders);
|
|
expect(headers.cookie).toBe('theme=dark');
|
|
expect(headers.cookie).not.toContain('codeman_session');
|
|
});
|
|
|
|
it('sends no cookie header when the browser only has the Codeman session cookie', async () => {
|
|
await connectThroughProxy('codeman_session=SECRET');
|
|
|
|
const headers = await within(upgradeHeaders);
|
|
expect(headers.cookie).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('managed DeepSeek web cookie', () => {
|
|
const COOKIE = 'dsh-auth-test=v1.payload.sig';
|
|
const upstreams: Array<{ port: number; cookies: Array<string | undefined>; close: () => Promise<void> }> = [];
|
|
|
|
/** A real loopback listener, so the assertion is on the bytes dsh would receive. */
|
|
async function startUpstream() {
|
|
const cookies: Array<string | undefined> = [];
|
|
const server = http.createServer((req, res) => {
|
|
cookies.push(req.headers.cookie);
|
|
res.writeHead(200, { 'content-type': 'text/plain' });
|
|
res.end('ok');
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const address = server.address();
|
|
if (!address || typeof address === 'string') throw new Error('upstream has no address');
|
|
const upstream = {
|
|
port: address.port,
|
|
cookies,
|
|
close: () => new Promise<void>((resolve) => server.close(() => resolve())),
|
|
};
|
|
upstreams.push(upstream);
|
|
return upstream;
|
|
}
|
|
|
|
/** The stub answers for one port and one owner, like the supervisor's two checks. */
|
|
function mintCookieOn(port: number, owner: string | undefined): void {
|
|
getDeepSeekWebCookie.mockImplementation((askedPort, askedOwner) =>
|
|
askedPort === port && askedOwner === owner ? COOKIE : null
|
|
);
|
|
}
|
|
|
|
async function openManaged(url: string): Promise<string> {
|
|
const created = (await create({ name: 'DeepSeek Harness', url, managed: 'deepseek-web', trusted: true })).json()
|
|
.data;
|
|
const opened = (await app.inject({ method: 'POST', url: `/api/webviews/${created.id}/open` })).json().data;
|
|
return capabilityFromProxyPath(opened.embedUrl)!;
|
|
}
|
|
|
|
const getThrough = (cap: string) => app.inject({ method: 'GET', url: `/webview/${cap}/` });
|
|
|
|
async function writeUsersFixture(users: Array<{ username: string; role: string; canBypassPermissions: boolean }>) {
|
|
await fs.writeFile(
|
|
path.join(tmpDir, 'users.json'),
|
|
JSON.stringify({
|
|
version: 1,
|
|
users: users.map((user) => ({
|
|
...user,
|
|
password: { algo: 'scrypt', N: 1, r: 1, p: 1, salt: '00', hash: '00' },
|
|
createdAt: 1,
|
|
})),
|
|
})
|
|
);
|
|
// The store keeps a short cache; write through it instead of waiting for the TTL.
|
|
await readUsers(true);
|
|
}
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(upstreams.splice(0).map((upstream) => upstream.close()));
|
|
});
|
|
|
|
it('presents it to a managed tab on 127.0.0.1 at the minted port', async () => {
|
|
const upstream = await startUpstream();
|
|
mintCookieOn(upstream.port, undefined);
|
|
|
|
const cap = await openManaged(`http://127.0.0.1:${upstream.port}/`);
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(upstream.cookies).toEqual([COOKIE]);
|
|
expect(getDeepSeekWebCookie).toHaveBeenCalledWith(upstream.port, undefined);
|
|
});
|
|
|
|
it('presents nothing to a managed tab on another port', async () => {
|
|
const minted = await startUpstream();
|
|
const other = await startUpstream();
|
|
mintCookieOn(minted.port, undefined);
|
|
|
|
const cap = await openManaged(`http://127.0.0.1:${other.port}/`);
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(other.cookies).toEqual([undefined]);
|
|
});
|
|
|
|
it('presents nothing to an unmanaged tab on the same port', async () => {
|
|
const upstream = await startUpstream();
|
|
mintCookieOn(upstream.port, undefined);
|
|
|
|
const created = (await create({ name: 'Not managed', url: `http://127.0.0.1:${upstream.port}/` })).json().data;
|
|
const opened = (await app.inject({ method: 'POST', url: `/api/webviews/${created.id}/open` })).json().data;
|
|
const cap = capabilityFromProxyPath(opened.embedUrl)!;
|
|
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(upstream.cookies).toEqual([undefined]);
|
|
expect(getDeepSeekWebCookie).not.toHaveBeenCalled();
|
|
});
|
|
|
|
// `managed` comes from the client and the port is public, so this is the case
|
|
// the gate exists for: a regular user must not receive the starter's cookie.
|
|
it('presents nothing in multi-user mode when the owner has no privileged grant', async () => {
|
|
process.env.CODEMAN_MULTIUSER = '1';
|
|
currentUser = { username: 'bob', role: 'user' };
|
|
await writeUsersFixture([{ username: 'bob', role: 'user', canBypassPermissions: false }]);
|
|
const upstream = await startUpstream();
|
|
mintCookieOn(upstream.port, 'bob');
|
|
|
|
const cap = await openManaged(`http://127.0.0.1:${upstream.port}/`);
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(upstream.cookies).toEqual([undefined]);
|
|
expect(getDeepSeekWebCookie).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('presents it in multi-user mode to a granted owner who started the server', async () => {
|
|
process.env.CODEMAN_MULTIUSER = '1';
|
|
currentUser = { username: 'carol', role: 'user' };
|
|
await writeUsersFixture([{ username: 'carol', role: 'user', canBypassPermissions: true }]);
|
|
const upstream = await startUpstream();
|
|
mintCookieOn(upstream.port, 'carol');
|
|
|
|
const cap = await openManaged(`http://127.0.0.1:${upstream.port}/`);
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(upstream.cookies).toEqual([COOKIE]);
|
|
expect(getDeepSeekWebCookie).toHaveBeenCalledWith(upstream.port, 'carol');
|
|
});
|
|
|
|
// A record keeps the owner it was created under. Back in single-user mode the
|
|
// server is started with no starter, so comparing that stale owner would leave
|
|
// the tab on dsh's 401 for good.
|
|
it('presents it in single-user mode to a managed tab created under multi-user mode', async () => {
|
|
process.env.CODEMAN_MULTIUSER = '1';
|
|
currentUser = { username: 'carol', role: 'user' };
|
|
await writeUsersFixture([{ username: 'carol', role: 'user', canBypassPermissions: true }]);
|
|
const upstream = await startUpstream();
|
|
const cap = await openManaged(`http://127.0.0.1:${upstream.port}/`);
|
|
|
|
delete process.env.CODEMAN_MULTIUSER;
|
|
currentUser = undefined;
|
|
mintCookieOn(upstream.port, undefined);
|
|
expect((await getThrough(cap)).statusCode).toBe(200);
|
|
expect(upstream.cookies).toEqual([COOKIE]);
|
|
expect(getDeepSeekWebCookie).toHaveBeenCalledWith(upstream.port, undefined);
|
|
});
|
|
|
|
/**
|
|
* A loopback listener that completes the upgrade and records the cookie on the
|
|
* handshake. The realtime leg is a separate code path from `proxyRequest`, so
|
|
* the HTTP assertions above say nothing about what it puts on the wire.
|
|
*/
|
|
async function startWebSocketUpstream() {
|
|
const cookies: Array<string | undefined> = [];
|
|
const server = http.createServer();
|
|
const wss = new WebSocketServer({ noServer: true });
|
|
server.on('upgrade', (req, socket, head) => {
|
|
cookies.push(req.headers.cookie);
|
|
wss.handleUpgrade(req, socket, head, (client) => client.close());
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const address = server.address();
|
|
if (!address || typeof address === 'string') throw new Error('ws upstream has no address');
|
|
const upstream = {
|
|
port: address.port,
|
|
cookies,
|
|
close: () =>
|
|
new Promise<void>((resolve) => {
|
|
wss.close();
|
|
server.close(() => resolve());
|
|
}),
|
|
};
|
|
upstreams.push(upstream);
|
|
return upstream;
|
|
}
|
|
|
|
it('presents it on the websocket leg too, ahead of the browser cookies', async () => {
|
|
const upstream = await startWebSocketUpstream();
|
|
mintCookieOn(upstream.port, undefined);
|
|
const cap = await openManaged(`http://127.0.0.1:${upstream.port}/`);
|
|
|
|
// Upgrades need a real listener: inject() cannot carry them.
|
|
await app.listen({ port: 0, host: '127.0.0.1' });
|
|
const { port } = app.server.address() as AddressInfo;
|
|
const client = new WebSocket(`ws://127.0.0.1:${port}/webview/${cap}/ws`, {
|
|
headers: { cookie: 'codeman_session=SECRET; dsh-ui=dark' },
|
|
});
|
|
await once(client, 'open');
|
|
await waitUntil(() => upstream.cookies.length > 0);
|
|
|
|
// The credential leads so a stale browser copy cannot win, other dashboard
|
|
// cookies survive, and Codeman's own session cookie never goes upstream.
|
|
expect(upstream.cookies).toEqual([`${COOKIE}; dsh-ui=dark`]);
|
|
client.close();
|
|
});
|
|
});
|
|
|
|
describe('proxy HTML rewrite', () => {
|
|
// The request path is what the page's relative URLs are relative to. Proving
|
|
// it here (rather than only on rewriteHtml) pins that proxyRequest passes it.
|
|
it("resolves the document's relative base against its own directory", async () => {
|
|
const server = http.createServer((_req, res) => {
|
|
res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
|
|
res.end('<html><head><base href="./"></head><body>app</body></html>');
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const address = server.address();
|
|
if (!address || typeof address === 'string') throw new Error('upstream has no address');
|
|
|
|
try {
|
|
const created = (await create({ name: 'App', url: `http://127.0.0.1:${address.port}/app/page.html` })).json()
|
|
.data;
|
|
const opened = (await app.inject({ method: 'POST', url: `/api/webviews/${created.id}/open` })).json().data;
|
|
const cap = capabilityFromProxyPath(opened.embedUrl)!;
|
|
|
|
const res = await app.inject({ method: 'GET', url: `/webview/${cap}/app/page.html` });
|
|
expect(res.statusCode).toBe(200);
|
|
expect(res.body).toContain(`<base href="/webview/${cap}/app/">`);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('POST /api/webviews/probe', () => {
|
|
it('reports an unreachable target as a normal answer, not a 500', async () => {
|
|
// Port 1 is reserved and refuses instantly.
|
|
const res = await app.inject({
|
|
method: 'POST',
|
|
url: '/api/webviews/probe',
|
|
payload: { url: 'http://127.0.0.1:1/' },
|
|
});
|
|
expect(res.statusCode).toBe(200);
|
|
const probe = res.json().data;
|
|
expect(probe.reachable).toBe(false);
|
|
expect(probe.recommendedMode).toBe('proxy');
|
|
});
|
|
|
|
it('rejects an invalid URL up front', async () => {
|
|
const res = await app.inject({ method: 'POST', url: '/api/webviews/probe', payload: { url: 'file:///etc' } });
|
|
expect(res.statusCode).toBe(400);
|
|
});
|
|
});
|
|
|
|
describe('egress policy: link-local and cloud-metadata targets', () => {
|
|
it('refuses to SAVE a metadata address, in every spelling, with a message that says why', async () => {
|
|
for (const url of [
|
|
'http://169.254.169.254/latest/meta-data/',
|
|
'http://2852039166/', // decimal form of 169.254.169.254
|
|
'http://[fd00:ec2::254]/',
|
|
'http://metadata.google.internal/computeMetadata/v1/',
|
|
]) {
|
|
const res = await create({ name: 'IMDS', url });
|
|
expect(res.statusCode, url).toBe(400);
|
|
expect(res.body, url).toMatch(/Blocked URL/);
|
|
}
|
|
});
|
|
|
|
it('still saves the loopback dashboards the feature exists for', async () => {
|
|
expect((await create({ name: 'Grafana', url: 'http://127.0.0.1:4000/' })).statusCode).toBe(200);
|
|
expect((await create({ name: 'Local', url: 'http://localhost:3080/' })).statusCode).toBe(200);
|
|
});
|
|
|
|
it('the probe refuses the same targets up front, before any connection is attempted', async () => {
|
|
const res = await app.inject({
|
|
method: 'POST',
|
|
url: '/api/webviews/probe',
|
|
payload: { url: 'http://169.254.169.254/' },
|
|
});
|
|
expect(res.statusCode).toBe(400);
|
|
expect(res.body).toMatch(/Blocked URL/);
|
|
});
|
|
|
|
it('the proxy refuses a record saved before the rule existed with a 403, never a relay', async () => {
|
|
// Written straight to the store: the schema would refuse it today, which is
|
|
// exactly why the proxy must judge the target again at connect time.
|
|
await writeWebviews(tmpDir, [
|
|
{
|
|
id: 'legacy-imds',
|
|
name: 'legacy',
|
|
url: 'http://169.254.169.254/',
|
|
embedMode: 'proxy',
|
|
trusted: false,
|
|
createdAt: Date.now(),
|
|
},
|
|
]);
|
|
const cap = webviewCapabilities.mint('legacy-imds', undefined);
|
|
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
|
|
try {
|
|
const res = await app.inject({ method: 'GET', url: `/webview/${cap}/latest/meta-data/` });
|
|
expect(res.statusCode).toBe(403);
|
|
expect(res.body).toMatch(/link-local or cloud-metadata/);
|
|
expect(warn).toHaveBeenCalledWith(expect.stringContaining('refused by egress policy'));
|
|
} finally {
|
|
warn.mockRestore();
|
|
webviewCapabilities.revokeWebview('legacy-imds');
|
|
}
|
|
});
|
|
});
|