Raphaël Bosi
60f5964c64
Front components run untrusted third-party React in a Web Worker. That
worker previously shared the host origin, so it could reach
origin-scoped storage (the metadata-store IndexedDB, the
`twenty-sign-out` BroadcastChannel), cookies, and same-origin resources.
This runs the worker inside a `sandbox="allow-scripts"` (no
`allow-same-origin`) iframe, giving it an opaque origin where the
browser denies localStorage, cookies, IndexedDB, and BroadcastChannel
outright. The worker is kept inside the iframe (rather than a bare
iframe) so untrusted code always runs off the main thread; the
remote-dom render path is unchanged.
- **Transport:** host ↔ iframe ↔ worker over a re-transferred
`MessagePort` (`ThreadMessagePort`); a small bootstrap script is inlined
into the iframe via `srcdoc` (bundled at build time by a prebuild step)
and relays the port to the worker it spawns. Messages across the
boundary use a typed discriminated union with a single parse/guard.
- **Network:** under the opaque origin, direct fetches to the Twenty API
would be `Origin: null`, so the component source and SDK modules are
fetched through an allowlisted, credential-omitting `hostFetch` bridge
and blobbed inside the worker. The allowlist is single-sourced on the
host (http(s) origins only) and carried in the render context. The
bridge is mandatory (rendering fails closed if it is missing), refuses
redirects except for GET/HEAD to the known file-storage URLs, and caps
response body size.
- **SDK loading:** SDK client modules now load inside the worker through
the bridge, replacing the host-side SDK-blob state/effect/provider with
a pure `getSdkClientUrls` URL builder.
- **Isolation tests:** a unit test locks the sandbox attribute
(`allow-scripts`, never `allow-same-origin`); a browser test asserts the
worker actually gets an opaque origin with storage denied, probing
cookies by writing one rather than reading an empty jar.
Also adds a "List Companies" seed front component that queries workspace
data via the SDK client (exercising the bridge end-to-end),
single-sources the command-menu confirmation-modal result event name and
detail type in `twenty-shared` (previously a hand-synced duplicate), and
decomposes the renderer (bridge, sandbox, worker orchestration) into
small single-purpose utils with unit tests.
## How it works
```mermaid
sequenceDiagram
autonumber
participant Host as Host window (twenty-front · host origin)
participant Frame as Sandboxed iframe (allow-scripts · opaque origin)
participant Worker as Worker (untrusted component · opaque origin)
participant API as Twenty API (host origin)
rect rgb(238,242,248)
Note over Host,Worker: 1 — Boot handshake
Host->>Frame: create iframe sandbox="allow-scripts", srcdoc = inlined bootstrap script
Host->>Host: MessageChannel + ThreadMessagePort(port1)<br/>exports = host API + hostFetch
Frame-->>Host: READY
Host->>Frame: INIT + transfer port2
Frame->>Worker: spawn inlined Worker + re-transfer port2
Worker->>Worker: ThreadMessagePort(port)<br/>exports = render / updateContext
Note over Host,Worker: Port now entangles Host ↔ Worker directly
end
rect rgb(246,240,248)
Note over Host,Worker: 2 — Render
Host->>Worker: render(connection, { componentUrl, sdkClientUrls, hostFetchOrigins, token })
Worker->>Worker: override globalThis.fetch<br/>(Twenty origins → hostFetch)
end
rect rgb(248,244,238)
Note over Worker,API: 3 — Network via hostFetch bridge (opaque Origin:null cannot reach the API directly)
Worker->>Host: hostFetch(componentUrl, Bearer)
Host->>Host: origin allowlist + credentials:'omit'
Host->>API: fetch(componentUrl)
API-->>Host: source
Host-->>Worker: { status, headers, body }
Worker->>Host: hostFetch(sdkClientUrls.core / .metadata)
Host-->>Worker: SDK module sources
Worker->>Worker: blob each source in its own opaque origin → import() → run untrusted React
end
rect rgb(238,248,242)
Note over Worker,Host: 4 — Render mirror
Worker->>Host: remote-dom mutations (RemoteConnection)
Host->>Host: RemoteReceiver → RemoteRootRenderer → host DOM
end
Note over Worker: Opaque origin ⇒ browser denies localStorage,<br/>cookies, IndexedDB, BroadcastChannel
```
89 lines
2.5 KiB
TypeScript
89 lines
2.5 KiB
TypeScript
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
import { build, type Rollup } from 'vite';
|
|
|
|
const dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const projectRoot = path.resolve(dirname, '../..');
|
|
|
|
const sandboxBootstrapEntryPath = path.resolve(
|
|
projectRoot,
|
|
'src/remote/sandbox/sandbox-bootstrap.ts',
|
|
);
|
|
|
|
const generatedFile = path.resolve(
|
|
projectRoot,
|
|
'src/remote/sandbox/generated/frontComponentSandboxDocument.ts',
|
|
);
|
|
|
|
const replaceProcessEnvReferences = (code: string): string =>
|
|
code
|
|
.replace(/process\.env\.NODE_ENV/g, JSON.stringify('production'))
|
|
.replace(/process\.env/g, '{}');
|
|
|
|
const escapeClosingScriptTags = (code: string): string =>
|
|
code.replace(/<\/script/gi, '<\\/script');
|
|
|
|
const buildSandboxDocument = async (): Promise<void> => {
|
|
const buildResult = await build({
|
|
configFile: false,
|
|
root: projectRoot,
|
|
resolve: {
|
|
alias: {
|
|
'@/': path.resolve(projectRoot, 'src') + '/',
|
|
},
|
|
},
|
|
define: {
|
|
'process.env.NODE_ENV': JSON.stringify('production'),
|
|
},
|
|
build: {
|
|
write: false,
|
|
lib: {
|
|
entry: sandboxBootstrapEntryPath,
|
|
formats: ['iife'],
|
|
name: 'frontComponentSandboxBootstrap',
|
|
fileName: () => 'sandbox-bootstrap.js',
|
|
},
|
|
rollupOptions: {
|
|
plugins: [
|
|
{
|
|
name: 'define-process-env',
|
|
transform: replaceProcessEnvReferences,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
logLevel: 'warn',
|
|
});
|
|
|
|
const rollupOutputs = (
|
|
Array.isArray(buildResult) ? buildResult : [buildResult]
|
|
).filter((item): item is Rollup.RollupOutput => 'output' in item);
|
|
|
|
const sandboxBootstrapChunk = rollupOutputs
|
|
.flatMap((result) => result.output)
|
|
.find((item): item is Rollup.OutputChunk => item.type === 'chunk');
|
|
|
|
if (sandboxBootstrapChunk === undefined) {
|
|
throw new Error(
|
|
'Failed to build the front component sandbox bootstrap bundle',
|
|
);
|
|
}
|
|
|
|
const sandboxBootstrapScriptTag = `<script>${escapeClosingScriptTags(sandboxBootstrapChunk.code)}</script>`;
|
|
const sandboxDocument = `<!doctype html><html><head><meta charset="utf-8" /></head><body>${sandboxBootstrapScriptTag}</body></html>`;
|
|
|
|
const generatedSource = `export const FRONT_COMPONENT_SANDBOX_DOCUMENT = ${JSON.stringify(
|
|
sandboxDocument,
|
|
)};\n`;
|
|
|
|
fs.mkdirSync(path.dirname(generatedFile), { recursive: true });
|
|
fs.writeFileSync(generatedFile, generatedSource, 'utf8');
|
|
};
|
|
|
|
buildSandboxDocument().catch((error: unknown) => {
|
|
console.error(error);
|
|
process.exit(1);
|
|
});
|