UlikaDocs
Open Ulika

Getting started

  • Ulika documentation
  • How Ulika works
  • Requirements
  • Quickstart

Connect a site

  • Connect from the dashboard
  • Connect with the CLI
  • Connect with an AI agent
  • Approving a connection
  • Private previews
  • The GitHub App
  • Connect Vercel

Integrations

  • GitHub integration
  • Vercel integration
  • Netlify
  • Claude Code
  • Codex
  • MCP tools

Editing

  • The editor
  • The style panel
  • Sections and pages
  • Mobile preview, autosave and drafts

Publishing

  • Publish your changes
  • History and restoring a version
  • When a publish fails

Team

  • Team roles
  • Inviting people

Projects

  • Project settings
  • Delete a project
  • Website code

Troubleshooting

  • Needs attention reasons
  • Vercel problems
  • GitHub problems
  • CLI errors and exit codes
  • Frequently asked questions

Security and privacy

  • Security and privacy overview

CLI

  • CLI reference
  • CLI changelog

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 October 10, 2026

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 reads package.json and a few configuration files as plain text. It skips folders such as node_modules, .git, dist, build, .next, out, coverage, vendor, .turbo and .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:

FileWhat it is
.ulika/connector.jsonSettings for the connector: project id, Ulika's address, delivery mode, version. No secrets.
.ulika/bindings.jsonThe list of editable fields and where each one lives in your source.
.ulika/defaults.jsonYour current content, so your site builds even before anything is published.
.ulika/build.mjsThe build adapter that wraps your existing build.
.ulika/bridge.jsThe editor bridge. It is inert for normal visitors: it does nothing unless the page is inside the Ulika editor.
.ulika/live.jsThe small script that shows a publish before the rebuild finishes.
ulika.config.jsonThe site address and Ulika's address.
vercel.json, netlify.toml or package.jsonOne 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.json was 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, or ULIKA_CONNECTOR_TOKEN when 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:

PermissionLevelWhat Ulika uses it for
ContentsRead and writeRead: find your content. Write: the connector branch and the Publish commit.
Pull requestsRead and writeOpen the connector pull request and merge it when you ask.
MetadataReadRepository name, default branch and similar.
Commit statusesReadSee your host's build results.
ChecksReadSee your host's build results.
DeploymentsReadSee preview and production addresses and results.
Email addresses (account)ReadSign 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#

CredentialWho holds itHow it is storedLifetime
Your Ulika sign-in sessionYour browser (a cookie)Signed, HttpOnly, Secure in production, SameSite=Lax14 days
Your passwordThe sign-in serviceNot stored by Ulika. The sign-in service stores it hashed.Until you change it
GitHub App installation idUlikaEncrypted at rest (AES-256-GCM)Until disconnected
Vercel access token (pasted or from the integration)UlikaEncrypted at rest (AES-256-GCM), only opens for your workspace and teamUntil you disconnect
Vercel webhook secret and bypass secretUlikaEncrypted at rest (AES-256-GCM)Until removed
Site build tokensYour Vercel project and UlikaUlika stores only a SHA-256 hashReplaced on reconnect
CLI workspace token (ovl_wt_...)Your machineUlika stores only a SHA-256 hashUntil revoked (see below)
Agent token (ovl_at_...)The agent's machineUlika stores only a SHA-256 hash30 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 the ULIKA_TOKEN environment 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 logout only 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 connect gets 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.json in your repository, which is as public as your repository.

  • /cms/content.json on 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>/content on 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": false in .ulika/connector.json.

  • Your project id and Ulika's address, in .ulika/connector.json and ulika.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?

PreviousFrequently asked questionsNext CLI reference

On this page

  • The short version
  • What Ulika reads in your repository
  • What Ulika writes to your repository
  • 1. The connector pull request
  • 2. Content commits on Publish (Git delivery)
  • Auto-revert: the safety net for a bad merge
  • What Ulika does on your hosting
  • GitHub App permissions
  • Tokens and credentials
  • CLI and agent credentials
  • What data Ulika stores
  • Images and SVG files
  • What is public on your site
  • Account security
  • Known limits and things to know
Ulika documentationFAQ · CLI reference · Terms · Privacy