wishforge-ide/apps/ide/collaboration/test/isolated-oct.test.mjs
eust-w b47a07e8d2 chore: baseline snapshot of the Codex-delivered code before review
Imports the previously untracked working tree as-is so that the review
changes that follow (requirements -> design -> implementation) can be
reviewed as diffs and reverted if needed. No content changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 13:18:04 +08:00

99 lines
9.5 KiB
JavaScript

import { test } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import { randomUUID, webcrypto } from 'node:crypto';
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { createRequire } from 'node:module';
import { pathToFileURL } from 'node:url';
import { createGateway } from '../../gateway/server.mjs';
import factory from '../client-factory.cjs';
const require = createRequire(new URL('../../package.json', import.meta.url));
const protocol = await import(pathToFileURL(require.resolve('open-collaboration-protocol')).href);
const { io } = await import(pathToFileURL(require.resolve('socket.io-client')).href);
const { OpenCollaborationYjsProvider } = await import(pathToFileURL(require.resolve('open-collaboration-yjs')).href);
const Y = await import('../../node_modules/yjs/dist/yjs.mjs');
const { Awareness } = await import('../../node_modules/y-protocols/awareness.js');
protocol.initializeProtocol({ cryptoModule: webcrypto });
const execute = promisify(execFile);
const docker = (...args) => execute('docker', ['--context', process.env.WF_TEST_DOCKER_CONTEXT ?? 'colima', ...args], { timeout: 30_000 });
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
async function until(check, message) { const end = Date.now() + 10_000; do { if (await check()) return; await sleep(25); } while (Date.now() < end); throw new Error(message); }
async function listen(server) { await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); return `http://127.0.0.1:${server.address().port}`; }
test('two isolated OCT instances support scoped Socket.IO/Yjs collaboration and reject invite/token reuse across workspaces', { skip: process.env.WF_OCT_INTEGRATION !== '1', timeout: 60_000 }, async () => {
const names = [], connections = [], docs = [], awareness = [], sockets = [];
let api, gateway; const revoked = new Set();
const members = { alice: { workspace: 'workspace-a', role: 'developer' }, bob: { workspace: 'workspace-a', role: 'developer' }, charlie: { workspace: 'workspace-b', role: 'developer' }, viewer: { workspace: 'workspace-a', role: 'viewer' } };
try {
const origins = {};
for (const workspace of ['workspace-a', 'workspace-b']) {
const name = `wishforge-oct-test-${randomUUID().slice(0, 8)}`; names.push(name);
await docker('run', '-d', '--rm', '--name', name, '--read-only', '--cap-drop', 'ALL', '--security-opt', 'no-new-privileges', '--tmpfs', '/tmp:rw,noexec,nosuid,size=16m', '-p', '127.0.0.1::8100', '-e', `WF_WORKSPACE_ID=${workspace}`, '-e', 'WF_TENANT_ID=fixture-tenant', '-e', 'WISHFORGE_GATEWAY_ENFORCED=true', 'wishforge/oct-workspace:0.3.1-wf1');
const port = (await docker('port', name, '8100/tcp')).stdout.trim().split(':').at(-1); origins[workspace] = `http://127.0.0.1:${port}`;
await until(async () => { try { return (await fetch(`${origins[workspace]}/api/meta`)).ok; } catch { return false; } }, 'OCT did not start');
}
api = http.createServer(async (req, res) => {
let text = ''; for await (const bytes of req) text += bytes;
const request = JSON.parse(text), who = members[request.userToken], workspace = req.url.split('/')[3];
if (!who || revoked.has(request.userToken) || who.workspace !== workspace) { res.writeHead(403); res.end(); return; }
assert.equal(request.operation, 'edit');
res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ data: { tenantId: 'fixture-tenant', projectId: `project-${workspace}`, workspaceId: workspace, role: who.role, upstreamUrl: origins[workspace], collaborationUpstreamUrl: origins[workspace] } }));
});
const apiOrigin = await listen(api);
// Reserve a local port before gateway construction, which requires its public origin.
const reserve = http.createServer(); const publicUrl = await listen(reserve); await new Promise(resolve => reserve.close(resolve));
gateway = createGateway({ publicUrl, tenantId: 'fixture-tenant', serviceToken: 'gateway-fixture-token', apiOrigin, allowedUpstreamOrigins: Object.values(origins), allowedCollaborationOrigins: Object.values(origins), reauthorizeMs: 50 });
await new Promise(resolve => gateway.server.listen(Number(new URL(publicUrl).port), '127.0.0.1', resolve));
async function session(user) {
const workspace = members[user].workspace;
const launch = await fetch(`${publicUrl}/launch`, { method: 'POST', headers: { authorization: `Bearer ${user}`, 'content-type': 'application/json' }, body: JSON.stringify({ workspaceId: workspace }) });
if (!launch.ok) return { status: launch.status };
const { launchUrl } = await launch.json(); const response = await fetch(launchUrl, { redirect: 'manual' });
return { status: response.status, cookie: response.headers.get('set-cookie').split(';')[0], workspace };
}
const alice = await session('alice'), bob = await session('bob'), charlie = await session('charlie');
assert.equal((await session('viewer')).status, 403);
function client(user, displayName) {
const url = `${publicUrl}/workspaces/${user.workspace}/collaboration/`;
const localFetch = (target, init = {}) => fetch(target, { ...init, headers: { ...init.headers, cookie: user.cookie, origin: publicUrl } });
return factory.createPrefixConnectionProvider({ ...protocol, io: (origin, options) => { const socket = io(origin, { ...options, withCredentials: false, extraHeaders: { ...options.extraHeaders, Cookie: user.cookie, Origin: publicUrl } }); sockets.push(socket); socket.on('connect_error', error => console.error('OCT socket connection error:', error.message, error.description, error.context?.status, error.context?.responseText?.slice(0,300))); return socket; } }, { url, browserLocation: `${publicUrl}/workspaces/${user.workspace}/`, client: 'WishForge integration', fetch: localFetch, authenticationHandler: async (token, metadata) => {
assert.equal(metadata.providers[0].endpoint, 'api/login/simple');
return (await localFetch(new URL(metadata.providers[0].endpoint, url), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ token, user: displayName }) })).ok;
} });
}
const hostProvider = client(alice, 'Host display name'), guestProvider = client(bob, 'Guest display name');
const claim = await hostProvider.createRoom({ abortSignal: AbortSignal.timeout(10_000) });
const host = await hostProvider.connect(claim.roomToken); connections.push(host);
let hostIdentity; host.peer.onInfo((_origin, peer) => { hostIdentity = peer; });
host.peer.onJoinRequest(async () => ({ workspace: { name: 'fixture', folders: ['source'] } }));
host.room.onJoin((_origin, peer) => host.peer.init(peer.id, { protocol: protocol.VERSION, host: hostIdentity, guests: [peer], permissions: { readonly: false }, capabilities: {}, workspace: { name: 'fixture', folders: ['source'] } }));
await until(() => !!hostIdentity, 'Host peer did not connect');
const guestClaim = await guestProvider.joinRoom({ roomId: claim.roomId, abortSignal: AbortSignal.timeout(10_000) });
const guest = await guestProvider.connect(guestClaim.roomToken, guestClaim.host); connections.push(guest); guest.peer.onInfo(() => {});
let initialized = false; guest.peer.onInit(() => { initialized = true; });
await until(() => initialized, 'Guest did not receive encrypted initialization');
for (const connection of [host, guest]) { const doc = new Y.Doc(); const state = new Awareness(doc); docs.push(doc); awareness.push(state); const provider = new OpenCollaborationYjsProvider(connection, doc, state); provider.connect(); }
docs[0].getText('source/example.ts').insert(0, 'const greeting = "hello";');
await until(() => docs[1].getText('source/example.ts').toString().includes('hello'), 'Host edit did not reach guest');
docs[1].getText('source/example.ts').insert(docs[1].getText('source/example.ts').length, '\n// guest edit');
await until(() => docs[0].getText('source/example.ts').toString().includes('guest edit'), 'Guest edit did not reach host');
assert.equal(docs[0].getText('source/example.ts').toString(), docs[1].getText('source/example.ts').toString());
assert.equal((await fetch(`${publicUrl}/workspaces/workspace-a/collaboration/api/meta`, { headers: { cookie: charlie.cookie } })).status, 401);
const outsider = client(charlie, 'Allowed in other workspace');
await assert.rejects(() => outsider.joinRoom({ roomId: claim.roomId, abortSignal: AbortSignal.timeout(5_000) }), /Room not found/);
const tokenCheck = await fetch(`${origins['workspace-b']}/api/login/validate`, { method: 'POST', headers: { 'x-oct-jwt': hostProvider.authToken } });
assert.equal((await tokenCheck.json()).valid, false, 'Per-instance keys must reject another workspace OCT JWT');
revoked.add('bob');
await until(() => sockets[1].disconnected, 'Revoked member websocket was not closed');
assert.equal((await fetch(`${publicUrl}/workspaces/workspace-a/collaboration/api/meta`, { headers: { cookie: bob.cookie } })).status, 403);
} catch (error) {
for (const name of names) console.error((await docker('logs', '--tail', '15', name)).stdout);
throw error;
} finally {
for (const state of awareness) state.destroy(); for (const doc of docs) doc.destroy(); for (const connection of connections) connection.dispose(); for (const socket of sockets) socket.disconnect();
if (gateway) await gateway.close(); if (api) await new Promise(resolve => api.close(resolve));
await Promise.all(names.map(name => docker('stop', '-t', '1', name).catch(() => undefined)));
}
});