Przejdź do treści
Biblioteka skilli
DevOps i chmura · Nauka i wyjaśnianie

secure-origin

/secure-origin

Wyjaśnia, co obsługuje bezpieczny origin secure, dlaczego nic innego nie może z niego korzystać i jak go podłączyć do routingu.

Repozytorium
boxel ↗
Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

87/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność17 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
7
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wyjaśnia, co obsługuje bezpieczny origin secure, dlaczego nic innego nie może z niego korzystać i jak go podłączyć do routingu.

Oryginalny opis (EN)

What the secure origin (`secure.boxel.ai` / `secure.stack.cards`, `https://localhost:4208/secure` in development) serves, why nothing else may ever be served on it, and how it is wired — the realm-server gate that answers it ahead of all other routing, the dedicated development listener, its headers, and what is kept out of logs and Sentry. Use before adding a route, asset, mode or header to the secure origin; when wiring its hostname into a deployment; when a secure-origin request shows up in logs or Sentry; and when reviewing any change to `packages/realm-server/lib/secure-origin.ts`, `lib/s

Jak działa

  1. What it serves
  2. How the pages are built
  3. The credential fields the app frames
  4. How a mode talks to the realm server and the Matrix server
  5. Headers on every response
  6. How requests reach it
  7. What is never recorded
  8. Checks
Sekcje z nagłówków SKILL.md, w oryginale · 92 linii, 3 699 słów
Podgląd SKILL.md
---
name: secure-origin
description: What the secure origin (`secure.boxel.ai` / `secure.stack.cards`, `https://localhost:4208/secure` in development) serves, why nothing else may ever be served on it, and how it is wired — the realm-server gate that answers it ahead of all other routing, the dedicated development listener, its headers, and what is kept out of logs and Sentry. Use before adding a route, asset, mode or header to the secure origin; when wiring its hostname into a deployment; when a secure-origin request shows up in logs or Sentry; and when reviewing any change to `packages/realm-server/lib/secure-origin.ts`, `lib/secure-origin-telemetry.ts`, `packages/secure-origin/`, or the credential fields the app frames from it (`credentials.js`, host `components/matrix/credential-fields.gts`, `lib/credential-fields.ts`) — the sign-in, registration, password-reset, change-password and confirm-your-password inputs. Triggers on `secureOriginURL`, `--securePort`, `SECURE_ORIGIN_URL`, `--secureOriginAppOrigin`, `listenSecureOrigin`, `CredentialFields`, "secure window", "page shell", "credential fields", "frame-ancestors". For running a local host app against staging or production, and a password frame that is blank there, see the `local-host-against-remote` skill.
---

# The secure origin

**The governing fact: the secure origin is exactly as safe as the least trusted thing it serves.** It exists so that a credential typed into it can't be read by card code. The browser's same-origin policy does the isolating: the app page, and every card evaluated in it, can't read another origin's document, keystrokes or form values. That guarantee is about the _origin_, not the page. One script served anywhere on the origin, from any path, can read every window open on it. So the origin serves the pages `packages/secure-origin` builds — the shell, and the credential fields the app frames — and nothing else. No realm, card module, realm asset, host app bundle or third-party script, ever.

## What it serves

- **The shell**, at the path of the configured URL (`/` deployed, `/secure` in development): the built `index.html`, with no inline script, the files it loads (its entry point `shell.js`; the chunks that imports, among them `shared.js` with Ember and the components both entries use, the shell's own components staying in `shell.js`; `layers.css`, the order of the pages' cascade layers, which the build links ahead of every other stylesheet; and the components' stylesheets, `shell.css` among them with `global.css`'s page-wide rules: boxel-ui's reset, the typeface and the page's background), and boxel-ui's `variables.css`, `theme.css` and the app's typeface, read from boxel-ui as they are. `createSecureOrigin` builds a `routes` table of every path served, from the build's manifest (see below).
- **Modes** are added to `shell.js`'s `modes` table, keyed by the `mode` query parameter. Every mode is the same shell document, with the same headers. They are `sign-in`, `cli-sign-in` (`boxel keys sign-in`) and `cli-auth` (`boxel profile add`, which hands the CLI a Matrix login token; see the `secure-session` skill) (components in `src/shell/sign-in/`, mounted with `renderComponent`), `register` and `verify-email`, where a registration email's link lands (`src/shell/register/`), and `forgot-password` and `reset-password`, where a reset email's link lands (`src/shell/password-reset/`); Google returns to `google-callback`, which serves the shell too. `sign-out` ends the window's session and goes back to the app page in its `#return=`. An unknown mode renders nothing. A sign-in the app started carries `#return=` too, and the window hands it back with a login token (the `secure-session` skill); `return` is honoured only on an origin in the shell's `boxel-app-origins` markup, which the realm server fills with the credential fields' app origins.
- **The pages are the app's sign-in screens**, the same components in both places, and every one is a Glimmer component. `src/components/` holds AuthContainer, AuthButton, AuthFormField and AuthHeading (a screen's title, an `h1`, or an `h2` under a page that heads itself) and ports of the boxel-ui components they use (Button, FieldContainer, Label, BoxelInput, InputGroup, LoadingIndicator and the icons), each with boxel-ui's scoped CSS. `src/screens/` holds the screens themselves, presentational and stateless: sign-in, the registration steps and the password-reset steps, each taking its values and actions as arguments and its password fields as a block. The host renders its Login, RegisterUser and ForgotPassword from these, with its own controller (the Matrix service, the router) and the credential frame as the password fields (ADR 008 §1.9); the host may import from the package, and the package never imports from the host. On the secure origin, `src/shell/sign-in/` holds the sign-in form's controller, the CLI sign-in, the Google callback and the pages a sign-in ends on; `src/shell/register/` and `src/shell/password-reset/` hold account creation and password reset, with the host's RegisterUser and ForgotPassword rules, and render the same screens with the package's own inputs. The decisions behind them are plain modules: the CLI's loopback target and hand-off (`src/security/cli-handoff.js`), the registration's stages and the new account's first sign-in (`src/security/registration.ts`), and the reset link (`src/shell/password-reset/reset-link.ts`). The icon components copy boxel-ui's paths for the logo, Google's "G", the check mark and the spinner. A change to one of these screens' look or copy is made once, in the package, and reaches both origins. The CLI sign-in pages, the app's (`cli-auth.gts`) and the secure origin's (`src/shell/sign-in/cli-auth-page.gts`), render the sign-in screen too, naming themselves with the screen's `@title` and saying what signing in grants the CLI in its `intro` block, whose type and spacing the screen sets. Each screen's controls carry both origins' test attributes (`data-test-login-btn` beside `data-test-secure-password-submit`, and so on), so keep both when editing one.

- **The credential fields**, at `credentials` beneath the shell's path: the built `credentials.html` and the files it loads (its entry point `credentials.js` and `credentials.css`; the chunks it shares with the shell, `shared.js` and `shared.css`; `layers.css`; and `session.js`, imported to set a new password through the realm server), and the shell's typeface. See below.

Adding a screen means adding it to `packages/secure-origin`, as [ADR 008](../../../docs/adr/008-build-the-secure-origins-pages-as-their-own-ember-app.md) sets out. Each addition must be code this repo owns and reviews. Never add a proxy, a passthrough to realm routing, a CDN script, an analytics snippet or a host-app import.

The pages are deliberately not host components. ADR 008 records why: everything the origin serves is trusted code, so it is built from a package of its own, behind an import allowlist, with a reviewed record of what it ships.

## How the pages are built

`packages/secure-origin` is an Ember app built with Vite and Embroider. Templates are compiled at build time, and the build holds no runtime template compiler. It has two entry documents, `index.html` (the shell) and `credentials.html` (the credential fields). The pages' own modules are in `src/shell/` and `src/credentials/`. The security logic — the credential frame's protocol and forms, the Matrix requests, session handling, origin matching and response redaction — is in `src/security/`, which imports nothing from Ember, Glimmer or the pages (a `no-restricted-imports` rule enforces it).

- **The import allowlist.** `build/import-allowlist.ts` fails the build when its output holds a module from anywhere but the package and the packages it names (`ember-source`, `@glimmer/component`, `@glimmer/tracking`, and the build's runtime helpers), or any module of Ember's runtime template compiler. It reads the bundle, so it sees a module reached through a dependency's own imports. A stylesheet's `@import` and `url()` are inlined rather than bundled as modules, so the package's stylesheets may not `@import`, and a `url()` may name only a relative path inside the package (boxel-ui's typeface, served beside the stylesheet at run time, is one). Adding a package to the allowlist is a change to the origin's trusted code, and is reviewed as one.
- **`session.js` is an entry of its own**, so it is served whole with its exports under their own names: the matrix suite's `secure-window.spec.ts` imports it from the origin and calls it as the window does.
- **CSS.** Components style themselves as the host's do (ADR 008 §1.4): `<style scoped>`, compiled by `glimmer-scoped-css` into the build's stylesheet files, over boxel-ui's CSS variables and in `rem`. A scoped rule is scoped by a `data-scopedcss-…` attribute, not a `style` attribute, so it holds under the policy.
- **TypeScript.** The package's own code is `.ts` and `.gts`, in erasable syntax, so Node runs its scripts and tests directly (ADR 008 §1.10). `pnpm lint` type-checks it.
- **The build record.** `build-record.json`, committed, lists each file the entry documents load, its size, and each module in it by package, version and size. `pnpm build` rewrites it. `pnpm lint:build`, part of the package's lint in CI, rebuilds and fails when the output differs from it. So a bump to Ember or any allowed package shows, in its pull request, exactly what changes on the origin. Commit the record with the change that moves it.
- **The policy holds for the build.** No template binds or sets `style` (the template lint's `no-inline-styles` with `allowDynamicStyles: false`). Code that styles an element at run time uses the CSSOM (`element.style.setProperty`). Entry documents hold no inline script or style. The pages are never served from a Vite dev server, which injects styles inline.
- **Serving.** The build writes asset URLs under the placeholder base `/__SECURE_ORIGIN_BASE__/`, and `dist/manifest.json` maps each entry document to the files it loads. `createSecureOrigin` reads the manifest and the files once, at startup, and replaces the base with the shell's path. A realm server configured with a secure origin refuses to start without a build. Nothing is built at request time.
- **Where it is built.** Before every process that serves the origin starts: the realm-server image (`realm-server.Dockerfile`), the deployed start scripts (`scripts/start-staging.sh`, `scripts/start-production.sh`), the dev and host test stacks (`mise-tasks/services/realm-server`), the realm-server and boxel-cli integration suites (their `run-*-with-test-pg.sh`), and the matrix suite's global setup. `pnpm build:secure-origin` in `packages/realm-server` builds it by hand.

## The credential fields the app frames

Every input a password is typed into — sign-in, the CLI sign-in page, registration, password reset, change password, and the change-email modal's "confirm your identity" — is a cross-origin frame of `credentials#form=<form>&origin=<app origin>`. Unlike the secure window, the frame is meant to be invisible: the user sees the app's own form.

- **What the frame is told rides in the fragment, never the query.** A WAF rule in front of staging refuses any query string that contains `localhost` or `127.0.0.1`, so `?origin=http://localhost:4200` would be a 403 and a blank frame for every local host. The fragment is never sent to the server, so no filter sees it, and the load balancer's access log never records it. A page that isn't on the user's own machine passes them in the query as well (`credentialFieldsURL` in the host's `lib/credential-fields.ts`), and the frame reads the query when the fragment names no form, so a host bundle that sends only the query and a realm server that reads only the query each still work with the other side. Anything else the app or the CLI hands the secure origin that names an origin or a URL goes in the fragment or another channel that isn't the query, for the same reason.

- **Where a password goes is the realm server's, not the app's.** `createSecureOrigin` writes the Matrix server's URL (the realm server's `--matrixURL`) and the realm server's own (`serverURL`) into the page's markup, and names those two origins alone in `connect-src`. The frame sends every request carrying a password to the Matrix server, itself, but for `set-password`, which it sends to the realm server: the realm server sets the password on the Matrix server and then ends the account's secure sessions (the `secure-session` skill). Nothing the app sends can change either destination, so card code driving the frame can't redirect a password.
- **Framed by the app's origins alone.** `frame-ancestors` names `--serverURL`'s origin plus each `--secureOriginAppOrigin` (the host dev server and the test runner in development; the staging host PR previews' `https://*.boxel-host-preview.stack.cards` on staging; and on staging and production alike, a host app on the developer's own machine: `https://localhost:*`, `https://127.0.0.1:*` and their `http:` twins). No remote page can have a loopback origin, so those admit only a page served from the user's own machine: any such page, on any port, not only the host app. Production lists nothing else: a password manager fills a saved production password into the fields wherever they are framed, so a branch preview, a Railway deployment or a custom domain is added to staging's list by name, never production's. An origin whose host starts with `*.` stands for every subdomain of the rest, and one whose port is `*` for every port of its host, in `frame-ancestors` and in the frame's own check (`isListedOrigin`) alike. The realm server normalizes each configured origin with `appOrigin`, which refuses anything that isn't a single origin of that shape. The same list is written into the page, and the frame talks only to a parent on one of those origins, checking each message's origin and that it comes from its parent window. The host checks the frame's messages with `isTrustedMessageOrigin` and the frame's window.
- **What crosses the boundary.** The app sends what isn't secret: theme values, a username, an interactive-auth dict without its password, its own access token (change password, change email), and "make this request". The frame sends back whether each field is filled in and valid (never what is in it), its height, and the Matrix server's response — which for sign-in is the session the app already keeps. Before it goes, a response is checked for any password typed into the frame.
- **Card code can still drive the frame.** It runs in the app page, so it can send the frame the same messages the app does, and the frame can't tell the two apart. It can't read a password or change where one goes, but it can choose the non-secret parts of a request the user's password then authorizes — for example, the email verification session `add-threepid` binds. Keep every parameter the app sends to what a request can't do harm with, and fix in `credentials.js`, or in the realm server that a request goes through, anything that decides what a password authorizes (as the realm server fixes `logout_devices: true` for `set-password`).
- **Forms and requests are fixed in `credentials.js`.** Each form names its fields and the one request it may make; a request names its Matrix endpoint and the body it sends, taking from the app only the parts that aren't secret. A new form or field is added there and in the host's `CredentialForm` type, never by the app passing field definitions.
- **The protocol is a plain module; the fields are components.** `src/security/credentials.js` holds the frame's whole conversation with the app as a `CredentialFrame`: what each field holds, validation, the `state` and `size` it reports, the requests and their redaction. It renders nothing and is handed everything it reaches (the parent window, `postMessage`, `fetch`), so it is tested without a page. `src/credentials/` draws the fields from it (`credential-fields.gts`) and mounts them (`main.ts`) only when `mayStart` allows.
- **It looks like the app because the app styles it.** The fields are drawn with the package's ports of boxel-ui's FieldContainer, Label and BoxelInput and with AuthFormField (`src/components/`), each with its original's scoped styles. Every `var(--…)` in those styles is resolved by the host component at the frame's position and sent over, and written onto the frame's document through the CSSOM (`src/credentials/style.ts`), so a theme or token change reaches the frame. A change to boxel-ui's rules for FieldContainer, Label or BoxelInput needs the same change in the package's port. A layout that follows the space around it (the settings modal) sets `--credential-layout: narrow`.
- **A flow that re-sends the password keeps the frame mounted.** Registration and change-email retry their requests across several screens, so their forms stay mounted, hidden, until the flow ends. Unmounting the frame forgets the password.

## How a mode talks to the realm server and the Matrix server

A mode reads what it shows from the realm server, and sends what is typed there, never from or to the page that opened it. It does this with `fetch` to the realm server's own origin, cross-origin. The secure origin never serves realm-server endpoints itself: that would be the passthrough forbidden above.

Creating an account and asking for a reset email are Matrix requests the page makes itself (`matrix.js`): registration's user-interactive auth (the invite code where the Matrix server asks for one, and the email validation it polls for), and the email validation links. Setting the new password goes through the realm server (`changePassword` in `session.js`), which makes the Matrix request and then ends the account's secure sessions. The shell's policy names exactly two origins besides its own in `connect-src`, the realm server's (`serverURL`) and the Matrix server's (`--matrixURL`), both from the realm server's configuration and both written into the page's markup, never a wildcard. The endpoints a mode calls answer CORS for the secure origin.

An email link that lands on a mode carries anything secret in its fragment, never its query string, because a load balancer's access log records query strings: `reset-password`'s client secret is in the fragment, with the email address the link was sent to, and the Matrix server appends the validation session's id after them. The page reads them and takes them out of the address bar.

Submissions go through `fetch`, not a `<form action>`, so `form-action 'self'` stays as it is, but for the CLI's loopback hand-off.

- **Everything else is a 404**, on any method, with the same headers. A non-GET to the shell is a 405.

## Headers on every response

`secureOriginHeaders()` sets them, error responses included:

- `Content-Security-Policy: default-src 'self'; object-src 'none'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'`. There is no `unsafe-inline` and no `unsafe-eval`.
- `X-Frame-Options: DENY`, `Referrer-Policy: no-referrer`, `X-Content-Type-Options: nosniff`, `Cross-Origin-Resource-Policy: same-origin`, `Cache-Control: no-store`.
- `Cross-Origin-Opener-Policy: same-origin`. The page that opens a secure window keeps a handle to it. Same-origin policy stops that page reading the window, but not navigating it, so card code could swap the window for a look-alike partway through a flow. This policy cuts the handle: the opener sees the window as closed. It also cuts `postMessage` to the opener, which no mode uses. The app learns an outcome by asking the realm server again.
- No CORS headers: the gate runs before the realm-server's CORS middleware.

**Framing is per path, never per mode.** Every mode is one response, so relaxing framing on the shell would relax it for every mode, the key-entry window included. A document the app frames, such as the password forms, gets a path of its own and its own entry in `routes`. That entry's `headers` pass the app's origins in `frameAncestors`, which puts those origins in `frame-ancestors` and drops `X-Frame-Options`, since that header can't name an origin. An app origin may be a `*.` subdomain pattern the realm server is configured with, such as the staging host previews, or a `:*` port pattern, such as the loopback origins. Never pass a bare `*` or a scheme alone, and never relax the shell's route or the defaults.

## How requests reach it

- **Deployed:** the hostname has its own load balancer, which forwards everything on that host to the realm-server, keeping the `Host` header. `scripts/start-production.sh` and `scripts/start-staging.sh` pass `--secureOriginURL` (`https://secure.boxel.ai/`, `https://secure.stack.cards/`). Without that flag the realm-server treats the host like any other and serves the full app on it. A realm-server started anywhere the secure hostname reaches must carry the flag. `secureOriginGate` is the first middleware in `RealmServer#buildApp`. A request whose `Host` (or `:authority`) is the secure origin's host is answered there and never reaches CORS, request logging, the routes table or a realm. Keep it first.
- **Development:** `--securePort` opens a listener of its own (`RealmServer#listenSecureOrigin`) that serves only the secure origin, whatever `Host` it is sent. The listener is 4208 (`SECURE_PORT` and `SECURE_ORIGIN_URL` in `mise-tasks/lib/env-vars.sh`), on the dev realm-server that both `mise run dev` and the host test stack start. It is a different origin from the app (`localhost:4200`) and from the realm-server (`localhost:4201`), so isolation is real without DNS. In branch mode it is registered with Traefik as `realm-server-secure.<slug>.localhost`.
- The host reads the URL from `secureOriginURL` in its config: `SECURE_ORIGIN_URL` at build time, set for deployments in `packages/host/config/{staging,production}.env`.

The secure origin must never share a host with the realm-server, the host app or a published realm. Port 4201 would not do: it serves realm content and the host app.

## What is never recorded

- **Request logging** for the origin is its own: one `secure-origin <METHOD> <path>: <status>` line per request (logger `realm:secure-origin`). It records no query string, no headers and no body, because a ticket or a credential can travel in any of them. The realm-server's `realm:requests` logger never sees these requests. The `aws-access` skill shows how to find these lines and the load balancer's access logs in a deployed environment.
- **The load balancer's access log does record the query string.** So a ticket or anything secret travels in a request body, or in the URL fragment, which never leaves the browser. It never travels in the query string.
- **Sentry** records the body of any incoming request a handler reads. `scrubSecureOriginEvent` (installed in `instrument.ts` as `beforeSend` and `beforeSendTransaction`) reduces an event raised during a secure-origin request to its method and URL path. A host is covered once it is registered, which `createSecureOrigin` does.
- An error while answering is logged by message and turned into a 500 there and then. It is never rethrown to the app's error handler, which would report the request to Sentry.

## Checks

- `packages/realm-server/tests/secure-origin-test.ts`: the shell and its headers, 404s for realm, module, asset and server paths, the dedicated listener, and the telemetry scrub.
- `packages/realm-server/tests/secure-origin-test.ts` also covers the credential fields' route: `frame-ancestors`, `connect-src`, the Matrix URL, realm server URL and app origins written into the page, and their files. It also covers how `*.` and `:*` origins match, and the configured origins `appOrigin` refuses.
- `packages/realm-server/tests/secure-origin-policy-test.ts`: each of the shell's modes, and each credential form framed by an app page, loaded from the build in Chrome under the real policy, renders without a `securitypolicyviolation`. The same file checks, on the built shell, that every `.error` / `.error-message` colour rule (including those inside `@layer` blocks) and `--muted-foreground` meet 4.5:1 against AuthContainer's background; the package's component tests load no theme, so they can't.
- `packages/secure-origin`: `pnpm lint` (the import allowlist and the build record, through `lint:build`) and `pnpm test`, which is `test:unit` (Node: what the allowlist refuses) and `test:components` (QUnit in Chrome, against a development build with a tests entry: the `CredentialFrame` protocol without rendering, and each credential form's components). Every test module shares one page and one stylesheet, and the credential fields' stylesheet hides a document until it is styled, so `tests/test-helper.ts` marks the test page styled. CI runs `test:components` as the Secure Origin Tests job.
- `packages/host/tests/integration/components/matrix/credential-fields-test.gts`: a real card rendered beside the sign-in form, and beside the change-password form, finds no password input in the page and can't read the frame. The frame's URL carries its form and the page's origin in the fragment and has no query.
- `packages/host/tests/unit/secure-origin-isolation-test.ts`: the secure origin is neither the app's origin nor the realm-server's, and a page on the app origin can't read a document loaded from it. It loads the shell in a frame, not a window. Once the opener policy cuts a window's handle, nothing can close that window, and it would keep focus for every test after it. `mise-tasks/test-services/host` doesn't report the stack ready until the shell answers.

Wersje

W bazie nie ma innych skilli o nazwie secure-origin.

Migawka bazy z 13.11.2026 · wersja paczki 33e4b5cdc45a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 87secure-session
    Diagnozuje sesje zalogowane na bezpiecznym origin, ich wpisy w tabeli i sposób logowania oraz to, co odblokowują, np. klucze zapisu.
  • 84realm-sync
    Przenosi pliki między dyskiem a realmem Boxel: wysyła zmiany, pobiera realm, synchronizuje dwukierunkowo i listuje realmy.
  • 100mcp-server-sentry
    Instaluje serwer MCP Sentry do śledzenia błędów, stosów wywołań i triażu zgłoszeń oraz obsługuje jego narzędzia.
  • 90cdn-strategy
    Przenosi pracę na brzeg sieci, żeby żądania nie dochodziły do origin, z nagłówkami cache, unieważnianiem i origin shieldingiem, gdy obciążenie origin jest wysokie lub CDN prawie nie cache'uje.
  • 100huawei-cloud-cdn-origin-diagnosis
    Diagnozuje dostępność serwera źródłowego CDN i błędy pobierania z origin przez hcloud CLI: odczytuje konfigurację origin domeny i sonduje łączność skryptem Pythona, aby znaleźć przyczynę.
  • 90edge-cdn
    Projektuje konfigurację CDN: reguły cache, TTL i origin shield.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.