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
```
67 lines
1.8 KiB
TypeScript
67 lines
1.8 KiB
TypeScript
// Script to build seed front component .tsx files into .mjs using the same
|
|
// esbuild pipeline as the twenty-sdk CLI (Remote DOM + JSX wrapping).
|
|
//
|
|
// Usage: npx tsx scripts/build-seed-front-components.ts
|
|
|
|
import * as esbuild from 'esbuild';
|
|
import { existsSync, readdirSync } from 'fs';
|
|
import { join, resolve } from 'path';
|
|
import { getFrontComponentBuildPlugins } from 'twenty-sdk/front-component-renderer/build';
|
|
|
|
const ROOT_DIR = resolve(__dirname, '../../..');
|
|
const ROOT_NODE_MODULES = resolve(ROOT_DIR, 'node_modules');
|
|
|
|
const SEED_PROJECT_DIR = resolve(
|
|
__dirname,
|
|
'../src/engine/metadata-modules/front-component/constants/seed-project',
|
|
);
|
|
|
|
const alias: Record<string, string> = {
|
|
react: join(ROOT_NODE_MODULES, 'react'),
|
|
'react-dom': join(ROOT_NODE_MODULES, 'react-dom'),
|
|
};
|
|
|
|
const COMPONENTS = readdirSync(SEED_PROJECT_DIR, { withFileTypes: true })
|
|
.filter(
|
|
(entry) =>
|
|
entry.isDirectory() &&
|
|
existsSync(join(SEED_PROJECT_DIR, entry.name, 'index.tsx')),
|
|
)
|
|
.map((entry) => entry.name)
|
|
.sort();
|
|
|
|
const build = async () => {
|
|
for (const component of COMPONENTS) {
|
|
const entryPoint = join(SEED_PROJECT_DIR, component, 'index.tsx');
|
|
const outdir = join(SEED_PROJECT_DIR, component);
|
|
|
|
await esbuild.build({
|
|
entryPoints: [entryPoint],
|
|
bundle: true,
|
|
splitting: false,
|
|
format: 'esm',
|
|
outExtension: { '.js': '.mjs' },
|
|
external: [
|
|
'twenty-client-sdk/core',
|
|
'twenty-client-sdk/metadata',
|
|
'twenty-shared/*',
|
|
],
|
|
jsx: 'automatic',
|
|
sourcemap: false,
|
|
metafile: false,
|
|
minify: true,
|
|
logLevel: 'info',
|
|
outdir,
|
|
alias,
|
|
plugins: [...getFrontComponentBuildPlugins()],
|
|
});
|
|
|
|
console.log(`Built ${component}/index.mjs`);
|
|
}
|
|
};
|
|
|
|
build().catch((error) => {
|
|
console.error('Build failed:', error);
|
|
process.exit(1);
|
|
});
|