Open source · GitHub Action and CLI

Push to main.
Site updated.

Deploy a built site to any hosting you can reach over SFTP, SSH or FTP, including the cheapest plan with nothing on it to help you. One small file. No secrets in the repo.

$npx sealup init

Free, MIT. One bundled file on npm, no install scripts, Node 24 or later.

Before

How it is today

You know this one. Nobody is laughing: it is how most client sites still get shipped, and it has worked for years. It just costs you every time.

The upload

It is 11 pm. FileZilla on the left, the build on the right. The transfer takes twenty minutes, and you stay and watch it, because something always needs a retry.

The script

Or there is a script. It was written in an afternoon and it works. The FTP password is in it, and the script is in git, next to the code, on everyone's laptop.

The gap

Between the first file and the last, the site is half old and half new. Someone is on it right now. You hope they do not refresh.

None of this is a people problem. The tools were built for moving files, not for releasing a site. sealup was built for the second thing, on the same hosting.

After

How it could be

A push to main, or one command on your laptop. Only the files that changed go up, the old ones sealup put there come down, and a visitor never gets a half-written file. Here is a redeploy.

sealup deploy · ssh.example.com
$ sealup deploy
  ssh.example.com  sftp://deploy@ssh.example.com:22/home/site
  host key    SHA256:8H38JEnHSrMlcjtEnYeJa5rF1sOMfr07rcpM5uV9ftM  verified

  14 to upload · 9 to delete · 30 unchanged                       2.1 MB

  ✓ Sealed up and delivered: 14 files to ssh.example.com in 3.1 s.
    9 old files removed · https://example.com

Only changed files travel

A file list with sizes and SHA-256 stays on the server. A redeploy sends the files that changed, not the whole build. About 2 seconds when nothing changed.

Never half-uploaded

A file that replaces one on the server goes up under a temporary name and is renamed once it has fully arrived. Old files are deleted only after every upload is in.

No secrets in the repo

The password comes from the environment and is masked in CI. Over SFTP and SSH the server's host key is pinned, so a run talks only to your server.

The file

One small file.

sealup.yml, five lines, committed with the project. The password itself is not in it: only the name of the variable that holds it.

sealup.yml5 lines · host key shortened
server: sftp://deploy@ssh.example.com/home/sitepassword: ${SEALUP_PASSWORD}hostKey: ssh-ed25519 AAAAC3Nz…Lywt86upload: disturl: https://example.com

npx sealup init asks for the server URL and the password, shows the host key (or certificate) to confirm, and writes the first four lines, a git-ignoredsealup.env and the GitHub workflow.

Where it goes

One URL, protocol first: sftp://, ssh://, ftps:// orftp://. User, host and folder on the same line.

What stays out of git

${VAR} is read from the environment: sealup.env on your machine, a repository secret in CI. The host key means a run talks only to your server. A public repo can keep the server and the host key out of git too: npx sealup init asks.

What goes up

upload: dist: your build folder becomes the server folder. Theurl is printed under the success line and becomes the deployment link on GitHub.

In GitHub Actions

One step in the workflow you already have.

Add the sealup step after the build step of the workflow that runs on main, with the password as a repository secret. Every successful build deploys, and the run ends on a summary you can read without opening the log.

The step you add

.github/workflows/deploy.yml
- uses: sealup/sealup@v0.2.2  env:    SEALUP_PASSWORD: ${{ secrets.SEALUP_PASSWORD }}

npx sealup init writes this step for you, in a whole workflow: checkout, install, build, deploy.

The summary on the run

deploy · summarySucceeded

Sealed up and delivered: 14 files to ssh.example.com in 3.1 s

Deployment target
Targetsftp://deploy@ssh.example.com:22/home/site
Host keyED25519 SHA256:8H38JEnHSrMlcjtEnYeJa5rF1sOMfr07rcpM5uV9ftM verified
Sitehttps://example.com
Files by outcome
WhatFilesSize
Uploaded142.1 MB
Deleted9
Unchanged3030 KB
From your laptop

The same tool, the same words.

The Action runs the CLI in the same process. Three commands cover a project: set it up, look at what a deploy would do, deploy.

01npx sealup init

Asks for the server URL and the password, shows the server's host key (or certificate) so you can confirm it, and writes sealup.yml, sealup.env and the workflow.

02sealup deploy --dry-run

Shows the plan and changes nothing on the server. There is no confirmation prompt: this is the review step.

03sealup deploy

Runs the plan and ends on the line you saw above. Exit 0 means done; any other code says what stopped it and whether the server changed.

sealup deploy --dry-runnothing changes
$ sealup deploy --dry-run  DRY RUN  nothing will change on ssh.example.com  ssh.example.com  sftp://deploy@ssh.example.com:22/home/site  host key    SHA256:8H38JEnHSrMlcjtEnYeJa5rF1sOMfr07rcpM5uV9ftM  verified  Would upload 4 files424 KB    + admin/main.1b7e9f30.js3 KB    + main.4f2a9c1e.js412 KB    ~ about.html5 KB    ~ index.html4 KB  Would delete 2 files  (sealup uploaded them; they are no longer in your build)    - admin/main.93c5b8e0.js    - main.8b1e3d07.js  41 unchanged  DRY RUN  nothing was changed. To apply: sealup deploy ssh.example.com
One tool

Works everywhere.

Every host is a little different: the protocol, what is installed on the server, the machine you deploy from. sealup is one tool for all of it, and nothing has to be installed on the server.

SFTP only, no shellMost shared plans.
The fast path: 64 requests in flight on one connection.
SSH with a shell
Changed files travel as one archive and are unpacked on the server.
FTPS, or plain FTP
Works, with a warning on every run over plain FTP.
No rsync, no git on the server
Nothing to install there. sealup only needs a login.
A Windows laptop
No rsync needed: one bundled file on Node 24 or later.
GitHub Actions or your terminal
The same tool, the same words, the same result.
Speed

Fast on cheap hosting.

On the shared host we measured, each request takes about 20 ms to come back. Sent one at a time, a few thousand files take minutes. sealup keeps 64 requests in flight on a single SFTP connection, so a cheap plan deploys like a bigger one.

12s

First deploy. About 6,000 files, 40 MB, over SFTP.

2s

Redeploy. Nothing changed, so nothing travels. The file list on the server says so.

Measured on a low-cost shared hosting plan, with a PHP API and an Angular build.

One request at a timeabout 20 ms each · waits in between
sealup: many in flight, one connectionthe waits overlap

Schematic, not to scale. Same files, same server, one connection; only the number of requests in flight changes.

Safety

Safe by default.

None of this is a setting you have to find and turn on. The dry run is there when you want it; the rest holds on every run, including the first.

Server identity pinned

Over SFTP and SSH the server's host key lives in sealup.yml, and a run connects only to the server that shows it. Over FTPS the certificate is checked as a browser does, or pinned the same way. A new or changed key is confirmed by a person, never in CI. Plain FTP runs with a warning, every time.

Dry run

sealup deploy --dry-run lists every add, change and delete, and changes nothing on the server.

Never a half-written file

An upload that replaces a file goes to a temporary name and is renamed once it has arrived. Deletes run only after the last upload is in.

Secrets never print

Not in the terminal, not in the log. In CI they are masked before anything is written.

Seal it up, send it off.

$npx sealup init