Security and privacy
Security and privacy overview
What Ulika reads and writes in your GitHub repository and hosting, which permissions and tokens it uses, what it stores, and what stays public on your site.
Last updated
Ulika connects to your website's code and hosting so that people can edit the site without touching the code. That is a lot of trust, so this page lists exactly what Ulika can see and change, which credentials it holds, where it keeps them, and which safeguards stop mistakes. Where something is a known limit, it says so.
The short version#
Your code is data to Ulika, never something it runs. Ulika reads your repository as text. It does not install packages, run your build, or execute anything from your repository.
It never writes to your default branch to install itself. The connector arrives as a branch and a pull request that you (or an agent you approved) merge, with the full diff visible first.
Your production site is only changed by merging that pull request and by publishing. Both are explicit actions.
If a connector merge breaks your live build, Ulika reverts its own change.
Your secrets are not committed. The connector files contain no token.
Tokens are stored hashed or encrypted, and never shown again.
What Ulika reads in your repository#
When you connect a site, Ulika reads the repository through your GitHub App installation to find the text, images and links on your pages.
Read at a single commit. Ulika downloads a snapshot of the repository at one commit as a compressed archive and processes it in memory while streaming. It never clones, never writes your files to disk, and discards everything when the request ends.
Only the files it needs. It inspects source files (
.tsx,.jsx,.ts,.js,.mjs) and readspackage.jsonand a few configuration files as plain text. It skips folders such asnode_modules,.git,dist,build,.next,out,coverage,vendor,.turboand.vercel, skips symbolic links, and skips large files.Hard limits. A run stops with a clear outcome ("too large", "unsupported") instead of running forever. The limits include 512 MB downloaded, 3,000 files inspected, 256 KB per file and 60 seconds per run. Very large repositories are reported as too large; the CLI can connect those from your own machine.
What it keeps from the scan. The editable values it finds (text, links, image references and where they live in your source), so you can edit them. It does not keep a copy of your repository.
Ulika also fetches your public website to detect the framework and hosting. Those requests are limited to public HTTPS addresses: Ulika refuses addresses that resolve to private or internal networks, re-checks every redirect, sends no cookies or credentials, and caps the response size and time.
What Ulika writes to your repository#
Ulika makes two kinds of writes. Both are bounded and visible.
1. The connector pull request#
Installing the connector creates a new branch (named ulika/setup, with a suffix if that name is taken) from the exact commit Ulika analysed, and opens a pull request. Ulika:
shows you the complete list of files and every changed line before anything is created;
never writes to your default branch, never force-pushes, never deletes a branch and never rewrites history;
refuses to proceed if your default branch has moved since it read your code, rather than producing a pull request that would undo newer work;
only merges the exact commit it created: if someone pushes to the connector branch afterwards, it stops and tells you.
The files it adds depend on your framework. For sites built with Vite, Create React App and similar Node builds, the connector is these files, relative to the site's folder:
| File | What it is |
|---|---|
.ulika/connector.json | Settings for the connector: project id, Ulika's address, delivery mode, version. No secrets. |
.ulika/bindings.json | The list of editable fields and where each one lives in your source. |
.ulika/defaults.json | Your current content, so your site builds even before anything is published. |
.ulika/build.mjs | The build adapter that wraps your existing build. |
.ulika/bridge.js | The editor bridge. It is inert for normal visitors: it does nothing unless the page is inside the Ulika editor. |
.ulika/live.js | The small script that shows a publish before the rebuild finishes. |
ulika.config.json | The site address and Ulika's address. |
vercel.json, netlify.toml or package.json | One edit that makes your host run the Ulika build step, which wraps your existing build command. |
For Next.js App Router sites, the connector is a small ulika folder beside your app folder, two routes under app/cms/ (the published content and a build proof), plus one edit to your root layout that adds the editor bridge. No dependency is added, so your lockfile is unaffected. In both cases Ulika adds no package dependency and no secret.
Your own source files are not rewritten in the repository. At build time the adapter temporarily applies your published content to the source, builds, and restores the files.
2. Content commits on Publish (Git delivery)#
Sites connected with the current connector publish by committing one file, .ulika/content.json, when someone clicks Publish. This is the only time Ulika writes to your default branch. It is tightly limited:
One file only. The commit must change exactly that path, or it is refused.
Fast-forward only. Ulika never force-pushes. If your branch moved while publishing, it re-reads and retries a few times, then asks you to publish again.
Never over someone else's edit. If
.ulika/content.jsonwas changed outside Ulika, the publish stops and writes nothing. You choose Overwrite with Ulika's version or look at the change first.Protected branches stay protected. If your branch rules refuse the direct commit, Ulika opens a pull request (on a branch named
ulika/content-...) instead and waits for it to be merged. It never asks to bypass your rules.Attributable. The commit message is
content: publish N changes (Ulika), authored by the Ulika GitHub App, so you can find every one in your history.
Drafts never leave Ulika. Only the snapshot of a release that someone published is committed.
Auto-revert: the safety net for a bad merge#
When Ulika merges the connector for you (when you chose automatic merge with --auto-merge or the approval-page box, or when you click Activate on a preview it could not read), it treats the connector as live only once your production site actually serves it. If your host reports that the production build of the merge commit failed, Ulika reverts its own change:
it restores every file the connector changed to its earlier version, and removes the files it created, as one new commit on a branch named
ulika/revert, through a pull request;if any of those files was edited by someone after the merge, it does not revert, writes nothing, and puts the site on the attention list instead;
it never reverts a merge a person made themselves, and never force-pushes or deletes a branch.
Your host keeps serving the previous deployment while a build fails, so the revert restores your build, not your site. See Failed builds.
What Ulika does on your hosting#
Ulika's hosting integration today is Vercel. With your Vercel access, Ulika can:
set one environment variable on the project (
ULIKA_BUILD_TOKEN, orULIKA_CONNECTOR_TOKENwhen the first name is already used by something else) for sites that fetch content at build time;create a deploy hook named
Ulika <project id>so a publish can trigger a rebuild;register a webhook so it hears about deployments (only when connected with an access token; Vercel does not allow integrations to create webhooks);
create a Protection Bypass for Automation secret when previews are behind Vercel's login wall (only if Vercel allows it);
read your projects, domains and deployments, and start a preview build for the connector branch.
Ulika only changes things it created. It records the ids of what it makes, never touches a variable, hook or secret that is yours, and removes only its own items when you disconnect or delete a project. See Vercel for how the connection works.
GitHub App permissions#
Ulika uses a GitHub App, not a personal access token. You install it on an account and choose exactly which repositories it can see. It asks for these permissions and no others:
| Permission | Level | What Ulika uses it for |
|---|---|---|
| Contents | Read and write | Read: find your content. Write: the connector branch and the Publish commit. |
| Pull requests | Read and write | Open the connector pull request and merge it when you ask. |
| Metadata | Read | Repository name, default branch and similar. |
| Commit statuses | Read | See your host's build results. |
| Checks | Read | See your host's build results. |
| Deployments | Read | See preview and production addresses and results. |
| Email addresses (account) | Read | Sign in with GitHub, using only a verified primary address. |
It requests no Administration, Actions, Secrets or Workflows permission, and nothing organisation-wide. The three build-result permissions are read-only and optional: if they are not approved, everything still works and Ulika checks your live site after merging instead. If an installation only has read access, Ulika stops before writing anything and tells you which permission is missing. See GitHub App.
How the App's credentials are used:
GitHub gives Ulika short-lived access tokens (about an hour) for the repositories you selected. A token that can write is limited to one repository.
A build signal only counts when it comes from a listed hosting provider's own GitHub App, never from text in a repository or from a person.
Webhooks from GitHub are verified by signature before anything is read. The payload only says where to look; Ulika then re-reads the state from GitHub itself, so a forged event cannot mark anything merged or built.
Only one Ulika workspace at a time can publish into a given repository, so two workspaces cannot overwrite each other.
Tokens and credentials#
| Credential | Who holds it | How it is stored | Lifetime |
|---|---|---|---|
| Your Ulika sign-in session | Your browser (a cookie) | Signed, HttpOnly, Secure in production, SameSite=Lax | 14 days |
| Your password | The sign-in service | Not stored by Ulika. The sign-in service stores it hashed. | Until you change it |
| GitHub App installation id | Ulika | Encrypted at rest (AES-256-GCM) | Until disconnected |
| Vercel access token (pasted or from the integration) | Ulika | Encrypted at rest (AES-256-GCM), only opens for your workspace and team | Until you disconnect |
| Vercel webhook secret and bypass secret | Ulika | Encrypted at rest (AES-256-GCM) | Until removed |
| Site build tokens | Your Vercel project and Ulika | Ulika stores only a SHA-256 hash | Replaced on reconnect |
CLI workspace token (ovl_wt_...) | Your machine | Ulika stores only a SHA-256 hash | Until revoked (see below) |
Agent token (ovl_at_...) | The agent's machine | Ulika stores only a SHA-256 hash | 30 days, or revoked sooner |
General rules: tokens are never written to disk by the server, never put in URLs or logs, and never sent back to your browser, not even partly. The Settings screens show names and dates only. Errors from GitHub and Vercel are rewritten into Ulika's own messages and the provider's raw response is dropped.
CLI and agent credentials#
The CLI uses the approve-once-per-machine flow. You run ulika login (or ulika connect), a short code appears, and an owner approves it in the browser.
Workspace token. After approval, the CLI keeps a token in
~/.ulika/config.json, in a folder created with permissions only you can use. You can instead supply a token in theULIKA_TOKENenvironment variable, which wins over the file. Ulika only stores a hash of the token.It follows membership. A workspace token re-checks the owner's membership on every use. If the person is removed, or their role changes, it stops working.
ulika logoutonly forgets the token on that machine. It does not revoke it on the server. If a laptop is lost, remove the person from the team or change their role, which revokes their tokens.Agent tokens are narrower. An AI agent approved through
ulika connectgets a separate token with two scopes only: connect sites and read their progress. It cannot publish, edit content, read drafts, invite people or manage tokens. It expires after 30 days, is revoked after 14 days unused, and is revoked at once if you revoke it in Settings under Agents, if its approver leaves the workspace, or if GitHub access is removed.Organisations re-approve weekly. For repositories owned by an organisation, an agent's writes stop after 7 days until someone approves the machine again with
ulika connect --reapprove. This is because Ulika cannot see someone leave a GitHub organisation. Personal accounts are not affected.Agent codes are guarded. The short code can be tried only a few times before it expires, and guessing wrong codes from one address is rate limited.
What data Ulika stores#
Your account: name, email address and avatar colour. If you link GitHub, your GitHub login.
Your workspace: its name, plan label, members and their roles, and open invitations (stored as hashes, never the link).
Your projects: the editable fields Ulika discovered, their current values, drafts, published releases and version history, collection items, and page SEO data.
Your media: images and videos you upload (PNG, JPEG, GIF, WebP, AVIF, SVG, MP4, WebM).
Connection state: which repository and hosting project each site uses, the connector's state, and records of what Ulika created on your hosting so it can remove it later.
Connect run history: states, reasons and public links of connection attempts. It never holds tokens, draft values or repository file contents.
Ulika does not keep a copy of your repository, and it does not read your visitors' data. It does not run your site.
Deleting a project removes its fields, items, media records, versions and delivery state, and releases the objects Ulika created on your hosting. Your repository and your live site are not touched. See Delete a project.
Images and SVG files#
Uploads are checked by file signature, not just by name. SVG files are treated as documents that can contain scripts, so Ulika rewrites them from an allowlist instead of trying to filter bad parts: only drawing shapes and known-safe attributes survive. Scripts, event handlers, foreignObject, use, embedded images, links and styles are removed. If something was removed you see "Some effects in this SVG were removed for safety", and a file that cannot be made safe is refused with "This SVG can't be used as a picture", with advice to export plain shapes or use a PNG or WebP.
What is public on your site#
Connecting Ulika makes a few things public, because a visitor's browser has to be able to see your published content.
Your published content. The text, links, image addresses and style values you publish are, of course, visible on your live site. With Git delivery they are also in
.ulika/content.jsonin your repository, which is as public as your repository./cms/content.jsonon your site. Built sites include a small file that proves which release is live, with the published content.The instant-publish endpoint.
GET /api/live/<project id>/contenton Ulika returns only the snapshot of the latest published release, as plain text values and style declarations, so a visitor's browser can show a publish a few seconds before your rebuild finishes. It never contains drafts, who made a change, a change list, tokens or code. It is cached for a few seconds and rate limited, and an unknown or unpublished project answers with the same "not found" so it reveals nothing. You can turn it off per site by setting"live": falsein.ulika/connector.json.Your project id and Ulika's address, in
.ulika/connector.jsonandulika.config.json. They are identifiers, not credentials.
What is not public: drafts, your team, your tokens, your repository access, and the editor. The editor bridge only runs when your site is opened inside the Ulika editor, and it only accepts messages from Ulika's own address.
Account security#
Passwords. At least 12 characters and at most 72 bytes, not containing your email address, with a few different characters. Ulika does not enforce composition rules, because length matters most.
Sign-in with GitHub. Ulika reads your primary email only when GitHub reports it as verified, and links an existing Ulika account only when that address is confirmed there as well.
Confirmation. Where email confirmation is required, a new account must confirm its address before it can use the workspace.
Rate limits. Sign-up, resending confirmation emails, device codes, invitation sends and accepting invitations all have limits. The messages are deliberately uniform ("Too many attempts just now. Please wait a few minutes and try again.") so they do not reveal whether an address has an account.
Invitations. Links are random, stored as hashes, work once, expire after seven days, and only work for the invited address. See Inviting people.
Roles. Every action is checked against your role on the server. See Team roles.
Known limits and things to know#
A connector merge made on a preview Ulika could not read is verified on your live site after merging, with the automatic revert described above. A failed production build is detected for hosts that report production deployments to GitHub (Vercel does). Some other hosts report builds differently, so for them a failure is not detected and Ulika simply waits for proof instead of reverting.
Without the optional read permissions for build results, Ulika cannot see your host's builds and relies on checking your live site after merging.
The sign-in cookie is signed so it cannot be altered, and it is
HttpOnly, but it is not a substitute for protecting your own device.
Was this page helpful?