Docs / Sites

Sites

WordPress, PHP apps, or static sites on your own server, with automatic HTTPS, file access over SFTP, and daily backups. Sites from cPanel can be moved over together with their databases, and a site can be moved to another server with only a short pause.

Who it is for

Sites (Situs in the app) is built for app owners who used cPanel only to run their own site or app, not for hosting companies that sell accounts to many customers. It focuses on the functions people actually use: installing a site, domains and HTTPS, uploading files, databases, and backups.

Sites connect with the rest of Saka: the database can live on the same server or in a multi-location database cluster, and a site can sit behind a load balancer.

Site types

TypeWhat you getDatabase
WordPressInstalled automatically and ready to use (Indonesian or English). The admin password is randomly generated and shown in the panel.Yes
PHPApache with PHP 8.2, 8.3, or 8.4, and .htaccess works. For Laravel, CodeIgniter, or other PHP apps; upload files over SFTP.Yes
Statis (HTML) (Static)HTML/CSS/JS pages served directly by the web server. The lightest option.No
Pindahkan dari cPanel (Move from cPanel)Sign in to the old cPanel (like the WHM Transfer Tool), or use a cPanel backup file or a site archive. Files and database are moved, and WordPress is adjusted automatically. See Moving from cPanel.Yes

Creating a site

Server requirements: connected to Saka, ports 80 and 443 free (not used by another nginx or apache), and at least 1 GB of RAM.

  1. Open the Situs (Sites) menu in the panel, then press + Buat situs (Create site).
  2. Jenis (Type). Choose WordPress, PHP, Statis (HTML), or Pindahkan dari cPanel.
  3. Server. Pick the target server from the list of connected servers.
  4. Domain. Enter the domain, for example tokokue.id or blog.tokokue.id. For a root domain, tick Sertakan juga www (Also include www) if you want it. A domain can only be used by one site in your account.
  5. PHP & database (not for static sites). Choose the PHP version (8.3 recommended), the WordPress language, and where the database lives: Database di server ini (Database on this server) or Klaster database (Database cluster).
  6. Nama situs (Site name), for example "Toko Kue Ibu". For WordPress, this is also used as the site title (you can change it in WordPress).
  7. Press Buat situs (Create site), or Pindahkan situs (Move site) when moving from cPanel.

A site is usually ready in 2-5 minutes. The first site on a server takes a little longer because PHP is prepared first; a cPanel move depends on the size of the backup. You are also notified on Telegram. If it fails, the detail page shows why; delete that site and try again.

Domains, DNS, and HTTPS

No domain yet? When creating a site, press Use a free test address. Saka fills in <name>.<server-ip>.sslip.io, which works right away with HTTPS and no DNS setup. Switch to your own domain any time.

After the site is created, point the domain to the server in your domain's DNS manager (where you bought the domain, or Cloudflare). The Domain & HTTPS card on the detail page shows the records you need:

DNS
tokokue.id.       A      203.0.113.10
www.tokokue.id.   A      203.0.113.10
; optional, if the server has IPv6:
tokokue.id.       AAAA   2001:db8::10
Using Cloudflare?

Turn off the orange cloud first (choose "DNS only", grey cloud) until HTTPS is active in Saka.

Files over SFTP

Every site has its own SFTP account. Open the Akses (Access) card on the detail page and press Tampilkan sandi (Show password) to see the host, port, username, and password.

File manager

The File manager card on the site page replaces cPanel's File Manager, no SFTP app needed:

AI agents use berkas_daftar, berkas_baca, and berkas_ubah (with your approval).

Database

OptionWhat it isWhen to use it
Database di server ini (Database on this server, recommended)MariaDB 11.8 on the same server, one database and user per site, reachable only from that server.Regular sites on one server.
Klaster database (Database cluster)Saka creates a database and user for this site in your MariaDB cluster, and installs the Saka proxy on the site's server. Connections use TLS; if one database server goes down, the proxy moves to a healthy node.Sites that must keep running even if one database server goes down.

You can pick a MariaDB cluster that is ready and runs on other servers (the site's server must not be a member of that cluster). For WordPress, the TLS connection to the cluster is set up automatically. The database connection details (host, name, user, password) are in the Akses (Access) card. To view and edit the database contents, use phpMyAdmin.

phpMyAdmin

WordPress and PHP sites have their own phpMyAdmin. On the Access card, press Open phpMyAdmin; it opens in a new tab and signs you in.

Via the API: POST /api/v1/situs/{id}/phpmyadmin returns {"url"}, a single-use sign-in link valid for 60 seconds. phpMyAdmin is not available through MCP.

Backups and restore

Daily backups are stored on the same server as the site. To stay safe even if the server is lost completely, turn on backups to S3.

Backup restore test

A backup is only useful if it really restores. Once a month, at night (01:00 to 06:00 in the server time zone; UTC servers use WIB, UTC+7), Saka opens each site's latest backup in a temporary folder, imports its database into a temporary MariaDB, then runs the WordPress or PHP site in a temporary container and loads it once. The result shows on the site's Backups card (restorable or failed with the reason: broken archive, database that will not import, or a site that answers with an error) and in the monthly report. You are alerted when it fails. Press Test restore now to test at any time.

Through your AI agent: situs_uji_pulih, with the result in situs_status (uji_pulih).

Backups to your own S3

Site backups can also be sent automatically to your own S3 storage: Amazon S3, Cloudflare R2, DigitalOcean Spaces, Wasabi, Backblaze B2, or any S3-compatible service. If the server breaks or is deleted, sites are restored to a new server from there.

  1. Create a bucket just for backups (not public) and an access key that can read, write, and delete in that bucket.
  2. Open the server page, Backups to S3 card, press Set up S3. Pick the provider, fill in the region, bucket name, access key, and secret key, then Test & save. Saka tests writing, reading, and deleting before saving.
  3. Save the recovery code that appears (it starts with SAKA-S3-) in a password manager. It holds the S3 destination and the key that opens the backups.

Restore from S3

Through your AI agent: cadangan_s3_status, cadangan_s3_daftar, cadangan_s3_masa_simpan (change retention), and situs_buat with dari_s3. The S3 destination and recovery code are set only from the panel on purpose, so keys never pass through an AI agent.

Moving from cPanel

Choose the Pindahkan dari cPanel (Move from cPanel) type when creating a site. There are two ways to move.

Option 1: Sign in to the old cPanel (recommended)

Like the WHM Transfer Tool, but with just the cPanel account login. Saka creates a full backup on the old cPanel, waits for it to finish, downloads it to the new server, deletes that backup file from the old cPanel, and then sets it up.

  1. Old cPanel address: the domain or IP of the old server, for example oldshop.com. Port 2083 is used automatically (you can add your own :port).
  2. cPanel username and cPanel password (the cPanel account password, not the WHM or root password).
  3. If the account uses two-factor authentication (2FA), tick the API token option and enter a token from cPanel (Security, then Manage API Tokens). You can delete the token after the move.
  4. Tick Skip cPanel's HTTPS certificate check only if the old cPanel's certificate is self-signed.

Option 2: Use a backup file

  1. In the old cPanel, open Backup (or Backup Wizard), choose Download a Full Account Backup, then wait until the backup-….tar.gz file is ready.
  2. Fill in one of:
    • A download link for the backup file (it must be reachable from the internet), or
    • A file path on the target server, after you upload it to /root, /home, or /tmp, for example /root/backup-….tar.gz.

A plain site archive also works: a .zip or .tar.gz containing the site folder, with or without .sql files.

What Saka does

All of this is shown in the Catatan pemindahan (Move notes) box on the site's detail page. For a moved WordPress site, sign in with your old WordPress admin account.

Moving from Dokploy

When your VPS runs Dokploy (or Coolify), Saka recognises it automatically and leaves it alone: its Traefik keeps ports 80/443, Saka's firewall keeps the Dokploy and Docker Swarm ports open, and Saka sites and Kubernetes are not installed on that server. OpenClaw, Hermes, databases, VPN, and Shield still work there.

On that server's page, Move its apps to Saka lists every Dokploy app by project, read straight from Dokploy's database on that server, without an API key. Pick the apps and the target Saka server:

An overview of every way to move is in Moving to Saka. Dokploy is not changed. When it is done, point the domain's A record to the target server; the Dokploy app keeps running until you turn it off, and data changed there after the copy is not included. Not automatic yet: mounts of non-compose apps, and apps from a zip upload; each gets a note in the list. AI agents use the MCP tool dokploy_pindah.

Moving from Coolify

A server running Coolify is treated the same way: it is left alone, and Move its apps to Saka reads its apps straight from Coolify's database on that server, without an API key. Variables encrypted by Coolify are opened with the APP_KEY on that server, and {{project.X}}, {{environment.X}}, and {{team.X}} references are filled from shared variables.

Not automatic yet: apps built from a Dockerfile typed into Coolify without a repo, and storage of non-compose apps. MCP tool dokploy_pindah with platform: coolify.

Moving from aaPanel

A server running aaPanel is recognised and left alone too: its Nginx/Apache keeps ports 80/443, and Saka's firewall keeps the aaPanel panel port, phpMyAdmin (888), and FTP open. Move its apps to Saka reads the sites, domains, and databases straight from aaPanel's data on that server.

Not automatic yet: aaPanel Node/Python/Go/Java projects (use a Git app), FTP accounts (Saka uses SFTP per site), and a site's other databases besides its main one. MCP tool dokploy_pindah with platform: aapanel.

Moving from CyberPanel

A CyberPanel server (OpenLiteSpeed) is recognised and left alone too: OpenLiteSpeed keeps ports 80/443, and Saka's firewall keeps CyberPanel's panel (8090), OpenLiteSpeed admin (7080), FTP, email, and DNS ports open. Move its apps to Saka reads the sites, child domains, aliases, and databases from CyberPanel's internal database on that server.

Not automatic yet: CyberPanel email hosting and FTP accounts, and a site's other databases besides its main one. MCP tool dokploy_pindah with platform: cyberpanel.

Standalone databases into a cluster

PostgreSQL, MySQL, or MariaDB databases on Dokploy, Coolify, or aaPanel that no Git app uses (for example used by an app on another server) can be copied into a Saka database cluster: tick the database in the move dialog and choose the target cluster (PostgreSQL into a PostgreSQL cluster, MySQL/MariaDB into a MariaDB cluster). Saka opens a temporary path to that database on 127.0.0.1 of the old server only, copies it in one transaction through the cluster proxy, compares the row count of every table, then closes the path. The old database keeps running; afterwards create a user for the app on the cluster page and point the app at the cluster. MongoDB and Redis are not supported yet.

Move to another server

For changing VPS (for example to a bigger server or another location) without the hassle. The site is copied straight to the new server, and the old site keeps serving visitors until you are ready. The target server must be connected to the same Saka account, with ports 80/443 free.

  1. Copy. On the site's detail page, open the Move to another server card. Choose the Target server and PHP on the new server (you can change the PHP version, for example up to 8.4). For WordPress, tick Update WordPress, plugins, and themes during the move if you want. Press Copy to new server. The old site keeps running; you are notified on Telegram when the copy is ready. You can press Copy again at any time to refresh the copy.
  2. Move now. The old site shows a maintenance page (HTTP 503) briefly, the latest changes are copied, and the site goes live on the new server. If you chose the WordPress update, WordPress core, plugins, themes, and translations are updated after a backup; if the site breaks afterwards, it is rolled back automatically to the state before the update. If this step fails, the old site goes live again.
  3. Change DNS. Change the domain's A record to the new server's IP at your domain's DNS provider. The DNS column on the Domain & HTTPS card turns to pointing here afterwards.
  4. Finish. Once DNS points to the new server, press Finish (delete from old server). The site on the old server is deleted; its last backup is kept in /root on the old server.

Cancel is available until you finish. Before Move now, the copy on the new server is deleted and the old site is unchanged. After it, Cancel, go back to the old server makes the site live on the old server again and deletes the copy on the new server; changes made on the new server since the move are lost, and an A record you already changed needs to point back to the old server's IP.

How it works

Behind a load balancer

If a load balancer in proxy mode is ready and forwards the site's domain to this server, the site is automatically served through the balancer: visitors come in through the balancer, and the balancer holds HTTPS. The HTTPS column then shows di load balancer (at the load balancer). This is reapplied automatically when a load balancer is created or deleted, or when a balancer's IP changes.

PHP versions

Choose PHP 8.2, 8.3, or 8.4. On the PHP card, pick a version and press Ganti versi (Change version). The site restarts with the new version within a few seconds; a version that has not been used on that server yet is prepared first (about 1-2 minutes).

PHP settings

The same card has PHP settings, like cPanel's MultiPHP INI Editor but without editing files:

Press Save settings; the site restarts for a few seconds. Via the API: PATCH /api/v1/situs/{id} with php_ini; via MCP: the situs_atur_php tool.

Deleting a site

In the Zona berbahaya (Danger zone) section, press Hapus situs (Delete site) and type the site name to confirm. The site's files, database, SFTP account, and all its backups on the server are deleted. Your domain and server are not touched.

Tick Simpan cadangan terakhir dulu di /root server (Keep the last backup in /root on the server first, recommended) to copy one final backup to /root before the site is deleted. If that copy fails, the site is not deleted.

When you release a server, every site on it is cleaned up too; with the keep-backups option, each site's backup is copied to /root.

Ready-made apps

Install popular apps with one click, complete with a domain, HTTPS, and daily backups: open Sites, Create site, choose Ready-made app, then pick the app.

AppForMinimum RAM
n8nWorkflow automation without code1 GB
Uptime KumaMonitor sites & APIs, status pages512 MB
VaultwardenPassword manager (Bitwarden compatible)300 MB
MetabaseDashboards & reports from databases2 GB
NocoDBSpreadsheet-database (Airtable alternative)512 MB
GiteaSelf-hosted Git512 MB
MemosQuick notes with Markdown300 MB
NextcloudFiles, calendar, contacts (Google Drive alternative)1 GB
UmamiWebsite analytics (Google Analytics alternative), with its own PostgreSQL1 GB
GhostBlog & newsletter with memberships, with its own MySQL1.5 GB
ListmonkNewsletters & bulk email, with its own PostgreSQL512 MB

Through your AI agent: katalog_daftar, then situs_buat with jenis: "katalog" and katalog: "n8n"; update with situs_perbarui_aplikasi.

Apps from Git

Deploy your own app straight from a Git repository: Node (Next.js, Express, Vite), Python (Flask, FastAPI, Django), Go, PHP, Ruby, or anything with a Dockerfile. Every push deploys automatically, and if a new release misbehaves you roll back to the previous one with one click.

  1. Open Sites, Create site, choose App from Git.
  2. Enter the repo address and branch. Leave the branch empty to use the repo's default branch (e.g. main or master); addresses pasted from the browser like github.com/name/repo/tree/dev are cleaned up automatically and fill in the branch. For a monorepo, set Subfolder under advanced settings.
  3. Pick the server and domain, then create. The first deploy starts automatically; build steps show on the app page.

How it builds

Zero-downtime deploys, one-click rollback

A new release starts next to the old one, is health checked (the path is configurable), and only then do visitors switch over. If the new release fails to build, stops, or doesn't respond, the old release keeps serving and you are notified on Telegram. The last five releases are kept; Roll back here runs an older release in seconds without rebuilding.

Private repos (deploy key)

Private repos are read with a deploy key: an SSH key generated on your server for one app that can only read that one repo. Saka never asks for your password, token or GitHub account access. Until the key is added, the first deploy fails with The repo cannot be read from this server; that is expected.

  1. Use the SSH URL when creating the app: [email protected]:name/app.git (not https://github.com/...). On GitHub it is under Code, tab SSH. Already used an https URL? On the app page, card Repository & auto deploy, press Edit, change the URL and save.
  2. Copy the deploy key from the app page (section Deploy key (private repo), copy button). It is a single line starting with ssh-ed25519.
  3. Paste it in the repo, with write access off:
    • GitHub: repo, Settings, Deploy keys, Add deploy key. Any title (e.g. saka-server-name), paste the key, leave Allow write access unchecked.
    • GitLab: Settings, Repository, Deploy keys, Add new key, leave Grant write permissions unchecked.
    • Bitbucket: Repository settings, Access keys, Add key.
    • Gitea/Forgejo: Settings, Deploy Keys, Add Deploy Key.
    This needs repo admin rights. If you do not have them, send the key to the repo owner; it is safe to share because it is not the secret part (that stays on the server).
  4. Back on the app page, press Deploy now. Clone and build steps show on the app page.
  5. Optional: set up deploy on push so you do not need to press Deploy again.

Saka checks repo access before the first deploy. Until the key is added, no deploy runs (so there is no failed deploy); you get the key by Telegram or email, and the app page shows a Last step card with a Check & deploy button.

If it still fails:

The same app on a second server (two locations) or a fleet deploy uses the same key, so it is added only once. AI agents can help through MCP: they read the key from situs_status and ask you to add it (or use your own gh repo deploy-key add).

Deploy on push

The app page shows a Payload URL and Secret. In GitHub: Settings, Webhooks, Add webhook, Content type application/json, event Just the push event. GitLab and Gitea work too. Pushes to other branches are ignored; a push that arrives during a deploy is deployed right after it.

Environment variables

API keys, database URLs, and other settings go in the Environment variables card. Values are stored only on the server and not shown again; saving restarts the app without downtime. From inside the app, services on the server (for example the database cluster proxy) are reachable at host.docker.internal.

For secrets you make up yourself, such as SESSION_SECRET or JWT_SECRET, type the name and press Random: a random value is generated on the server and never shown, not even to an AI agent.

Persistent data folder

Every app from Git gets a /data folder that is not lost on deploy, rollback, or variable changes. Its location is in the DATA_DIR variable. Keep SQLite databases and uploaded files there, for example path.join(process.env.DATA_DIR || "./data", "app.db"). Workers and cron jobs use the same folder.

Outgoing email

To let the app send email (password resets, notifications, invoices), fill in the Outgoing email card with your email service's SMTP server (e.g. Brevo, Amazon SES, or Gmail with an App Password). It is stored as the variables SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS, SMTP_FROM, and SMTP_SECURE, which the app reads. Press Send test email: the email is sent from the app's own server. If the VPS provider blocks outgoing email ports (common on new accounts), Saka tells you and suggests port 2525 or asking the provider to open them. Saka does not offer email hosting.

Stay out of spam. On the same card, press Check DNS: Saka reads the sender domain's SPF, DKIM, DMARC, and MX through public DNS and shows the records to add for the email service in use (Brevo, Amazon SES, Google, Mailgun, SendGrid, Postmark, and more), each with a copy button. SPF that uses include or redirect is followed the way receivers read it. The domain's DNS is managed on your side (registrar or Cloudflare), and Saka tells you where; Saka only advises and does not change DNS. AI agents use email_dns_cek.

App check

On every deploy, Saka checks the code without stopping the deploy, which suits apps built with AI help:

Results are in the App check card (Check now checks without deploying). Important findings are sent by Telegram once per commit. AI agents use the MCP tool situs_periksa_aplikasi.

Bulk deploy: one app on many servers

For the same app on many servers (e.g. one VM per customer), open Bulk deploy and press + Create group: Saka groups your Git apps by repo and branch; just pick Make a fleet.

Workers & cron

Like a Procfile: on the Workers & cron card, add extra processes from the same release with the same variables. Commands run with sh -c inside the app container.

Pull request previews

Turn it on in the Pull request previews card, then in the repo's webhook settings also tick the Pull requests event (GitHub/Gitea) or Merge request events (GitLab). Every pull request to the app's branch (forks included) is built on your server and runs at https://pr-<number>-<id>.<server-ip>.sslip.io with HTTPS, no DNS setup needed. The address is sent on Telegram and updated on every push to that PR.

Through your AI agent and the API

curl
# deploy the latest commit, roll back, set variables
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/deploy -H "Authorization: Bearer $SAKA_TOKEN"
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/rollback -H "Authorization: Bearer $SAKA_TOKEN" -H "Content-Type: application/json" -d '{"commit": "<release tag>"}'
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/env -H "Authorization: Bearer $SAKA_TOKEN" -H "Content-Type: application/json" -d '{"env": {"MODE": "production"}}'

MCP tools: situs_buat (type git), situs_deploy, situs_rollback, situs_env, situs_proses (workers & cron), situs_cron_jalankan, situs_pratinjau, situs_email_uji, and situs_status to see releases and the last error.

Test sandbox. The MCP tool situs_ruang_uji (and POST /api/v1/situs/{id}/ruang-uji) runs one shell command on a copy of a WordPress, PHP or static site's files, in a throwaway container: no internet, read-only root, no capabilities, 256 MB RAM, 1 CPU, 128 processes, 300 seconds at most. You get the command output, the exit code, and the files that were added, changed or removed. The live site never changes. Useful for checking a site you suspect was hacked (grep -rlE "eval\(base64_decode" .) or checking syntax (php -l index.php) with no risk. Needs the sites permission and Docker on the server.

Binary services. The layanan site type runs a single binary (for example a Go app) directly on the server under systemd, without Docker, with a domain and automatic HTTPS. The binary runs as a locked-down system account with a read-only filesystem except one data folder, and environment variables are stored only on the server (their values are never read back through Saka). Create it with situs_buat type layanan (layanan.perintah, layanan.cek_sehat), then install a release: POST /api/v1/situs/<id>/layanan/rilis with {"berkas": "/root/server"} or {"url": "https://...", "sha256": "..."} (a binary or a .tar.gz). Saka copies it, runs the pre-command if any, switches the active release, restarts and checks health; if it is not healthy it returns to the previous release automatically. The last five releases are kept for rollback. There is a few seconds of downtime while restarting. MCP tools: layanan_status, layanan_rilis, layanan_rollback, layanan_env, layanan_atur, layanan_kontrol. The first version does not back up the data folder, cannot be moved to another server and does not support two-location replicas. Backups: the data folder and the service environment variables are included in the automatic daily backup, manual backups, S3 upload, Restore (with an automatic safety backup) and the restore test. The binary and releases are not (the last five releases stay on the server). The copy is taken while the service runs; a service that needs a consistent state (for example a file-based database) should write its own export into the data folder before the nightly backup. The cadangan_kecuali field (set when creating the service, a list of paths relative to the data folder) keeps caches the app rebuilds on its own out of the archive; they do not come back when you restore.

Saka Endpoint (managed remote desktop). Endpoint installs MeshCentral on your own server as a binary service, with a domain and automatic HTTPS: screen control, terminal and files from the browser, agents for Windows, Linux and macOS, no per-device fee. One server per customer: a problem on one server does not affect other customers and the data does not pass through a third party. Install with endpoint_pasang (MCP) or POST /api/v1/endpoint with {"server_id": "..."} (optional nama, domain, judul, email); follow progress with GET /api/v1/endpoint/<job>. The install takes about 5 to 10 minutes: it creates the service site, stores the settings, downloads the MeshCentral package (sha256 pinned by Saka), creates the first admin before the service opens, then removes the initial password from the server. The initial admin password is shown once in the install response; note it, then set up 2FA (required) at first login. Self-service sign-up is off, MeshCentral listens only on 127.0.0.1 behind Saka's web server, and the daily backup (database and agent keys) is part of the site backup, so existing agents reconnect after a restore without being reinstalled. A dedicated server is recommended (at least 2 vCPU and 2 GB RAM). Some antivirus products flag the Windows agent because it is a remote tool; allowlist it according to your policy.

Binary service egress limit. A binary service runs directly on the server, so Saka recognizes it by its system account (one account per service) and installs firewall rules in the outgoing chain (OUTPUT). The Restrict the addresses it may contact card on the site page has the same three modes as other apps: Monitor only (no rules), Simulate (records the internet destinations that would be blocked without rejecting anything) and Restrict (rejects anything not in the allow list). Private addresses, loopback, replies to incoming requests and the server DNS always stay allowed. Saka runs the enforcement test as the service account and cancels Restrict by itself if it fails; a 10 minute trial returns to Simulate unless confirmed. New destinations are only recorded in Simulate and Restrict, domain names do not show in the list, and IPv6 is not covered. REST: GET/PUT /api/v1/situs/{id}/layanan/egress; MCP: layanan_egress_batas and layanan_egress_atur.

Not yet available for Git apps: automatic backups (the code is in the repo; back up your database separately), one-click moves to another server (create the same app on the target server and deploy), and multiple servers behind a load balancer.

Docker Compose

The Docker Compose site type runs a docker-compose.yml you paste into the panel or one in a Git repo (found automatically as compose.yaml/docker-compose.yml, or give its path). Pick the web service and its port inside the container; Saka connects it to your domain with HTTPS. The Docker Compose plugin is installed automatically when missing.

Before running it, Saka rewrites your file (your original is not changed):

Variables fill ${NAME} in the compose file and are also written to .env in the project folder (for env_file: .env). The Docker Compose card on the site page shows every service and its state, logs per service, Stop/Start, and Redeploy (pulls the latest code when from Git).

Daily backups apply: the project folder plus the content of every named volume (services pause briefly so the data is consistent). Restoring puts the files and volume data back, then starts the services again.

Deploy automatically on push (Compose from Git): in the Docker Compose card, open Deploy automatically on push and add its Payload URL and Secret as a webhook on GitHub, GitLab, or Gitea. Every push to the app's branch pulls the latest code and restarts the services.

Moving to another server uses the same Move to another server card as regular sites: files, variables, the deploy key, and volume data are copied straight to the new server, the local port is adjusted, and the services start there. Services on the old server pause briefly each time their volumes are packed. A second location is not available for this type, because volume data cannot be shared between two servers.

Ready-made templates in the catalog run as Compose apps too: Supabase (from its official repo, with every secret and the anon/service_role keys created on the server), Cal.com, PocketBase, and Directus.

Databases for Git apps

In the App database card, add PostgreSQL, MySQL, MariaDB, MongoDB, or Redis for one Git app with a single click. The database runs on the same server, on that app's own Docker network, with no port open to the internet; the app and its workers reach it by host name (for example postgres). DATABASE_URL, DB_HOST, DB_DATABASE, DB_USERNAME, DB_PASSWORD (or REDIS_URL, MONGODB_URI) are set automatically with a random password; variables you set yourself still win. The app is redeployed so it reads them. The database is included in daily backups (it pauses briefly) and is put back on restore. Removing a database requires typing its type.

Logs

The Logs card on a site page shows logs read straight from the server when opened (not stored on Saka): App (Git & ready-made apps), Build (output of the last deploy build, successful or not), workers, Database (ready-made apps with a database), Errors & Access (WordPress/PHP), and Web server (HTTPS certificates and proxy errors for the site's domains). Follow refreshes every 3 seconds; Download saves a .txt file.

From the terminal: saka site log <name> build, or -f to follow (see CLI). AI agents use the situs_log tool.

Your own HTTPS certificate

By default every site domain gets a free Let's Encrypt certificate, installed and renewed automatically. Have a paid, wildcard, or EV certificate? On the site page, HTTPS card, press Use your own certificate, then paste or choose files:

Saka checks the key pair, validity, intermediate chain, and which domains are covered. Site domains not covered keep the automatic certificate. You're reminded on Telegram 30, 14, 7, 3, and 1 days before it expires, and can go Back to automatic at any time. Sites behind a proxy-mode load balancer use the balancer's HTTPS.

WordPress security & staging

WordPress sites get a WordPress security card on their site page.

Security check

Every day Saka checks the installed WordPress, plugin, and theme versions and alerts you about new important findings. The result is summed up as a score from 0 to 100.

Other findings from wordpress.org:

Update all takes a backup, updates WordPress, plugins, themes, and languages, then checks the site; if it breaks, the backup is restored automatically. Premium plugins not on wordpress.org cannot be checked for closure, but their updates are still detected if the plugin offers them.

Hardening

Below the findings is a list of settings that close common WordPress holes. Every row that is not safe yet has a Fix button:

New WordPress sites from Saka start with a random admin username (not admin), a protected wp-config.php, and PHP blocked in the uploads folder. AI agents can do the same through wp_keamanan and wp_kuatkan, with your approval.

File integrity

The daily check also compares WordPress core files and plugins from wordpress.org with their originals (checksums). Changed core or plugin files, and unknown files in wp-admin or wp-includes, are common signs of a hacked site and are flagged as important. Reinstall original files re-downloads WordPress core or that plugin (same version) and overwrites the changed files; site content, uploads, and settings stay, with a backup first and automatic restore if the site breaks. Unknown files are not deleted automatically: check and remove them over SFTP, then change the admin password.

File shield

For every WordPress, PHP, and static site, Saka answers 404 for files that must never be reachable from the internet even if they end up in the web folder: .git, .env, database dumps (.sql), backups such as wp-config.php.bak, debug.log, and error_log. It works in front of PHP, so it protects non-WordPress sites too. With the security check, file integrity, and this shield, a heavy security plugin inside WordPress is usually no longer needed; you can still keep one for its specific features.

Staging

Press Create staging to copy the site (files and database) to https://staging-<id>.<server-ip>.sslip.io with HTTPS and no DNS setup. Log in with the same WordPress account. On staging, outgoing email and WP-Cron are off (customers get no test emails, scheduled tasks do not run twice), and search engines are asked not to index it.

  1. Update on staging or change themes/plugins in the staging dashboard, then test the site.
  2. Push to live site, choosing:
    • Files only (recommended): WordPress, plugins, and themes from staging replace the live site's. The live database, uploads, and wp-config.php are not touched, so orders, comments, and new users stay safe.
    • Files and database: everything on staging replaces the live site, with addresses switched back to the live domain. Changes on the live site since staging was created are lost.
    Saka backs up the live site first and restores it automatically if the site breaks after the push.
  3. Delete staging when you no longer need it (removes the copy and its database; the live site does not change).

Staging needs a server with a public IPv4 and free disk about the size of the site. MCP: wp_keamanan, wp_perbarui, wp_nonaktifkan_plugin, wp_staging.

Monitored from the internet

Every minute Saka opens each site's main domain over the internet, like a visitor would. The site page shows whether it opens, its response time, and 30-day uptime. If the site can't be opened for more than 3 minutes while its server is connected, you're told on Telegram (or by email if Telegram isn't linked) with the cause: DNS missing or pointing elsewhere, an expired or wrong-domain HTTPS certificate, port 443 closed, no answer from the server, or a 5xx error from the app. You're told again when it recovers.

Sites that have never opened (e.g. the domain's DNS isn't pointed yet) don't trigger alerts; monitoring starts after the first successful open. An automatic certificate with less than 7 days left means its renewal failed, and that is reported too. Monitoring requests use the SakaPanel-Pantau User-Agent.

Checked from two locations. Checks run from Singapore. When a site fails from there, Saka immediately checks it again from Bangalore (another network and country). An outage is only counted in uptime and reported when both locations fail, so a network problem at one point does not cause a false alert. Outage alerts name the locations checked. This also applies to tunnels, load balancers, and external addresses.

Tunnels and load balancers are monitored too. The address of every active tunnel (<name>-app.hack.id) and the domain of every load balancer are checked the same way, and the result shows on the Tunnel page and the load balancer page. A Telegram alert is sent when one cannot be opened for more than 3 minutes.

Monitor addresses outside Saka

In Settings, the Monitor addresses outside Saka card watches any URL or API, including ones not on Saka: sites on other hosting, third-party APIs, mobile app endpoints. Checked from the internet every minute; outages longer than 3 minutes are reported (once the address has been up), and so are HTTPS certificates with less than 14 days left. Under Advanced settings, set a keyword that must appear in the response (useful when an error page still answers 200) or the expected HTTP status (e.g. 401 for an API that requires login). Up to 20 addresses per account; internal network addresses (private IPs, loopback, cloud metadata) are refused. External addresses can go on a public status page and are in the monthly report. MCP: pantau_luar.

Monthly report

On the 1st of every month at 08:00 WIB, Saka sends last month's report: outages and bandwidth per server, availability and downtime per site, tunnel, load balancer, and external address, bandwidth and WordPress security score per site, certificates expiring within 30 days, and alert counts. Full by email (when verified) and short over Telegram. Set it up in Settings, Monthly report card (on/off, preview this month, send now). For agencies, add client emails in the Report for your client card on the site page (up to 3): the client only receives that site's report, without your servers or other sites. The site page also shows this site's bandwidth per month and per day; a single site's spike (at least 2 GB a day and five times its average) is reported with the site's name. MCP: laporan_bulanan.

Public status page

In Settings, the Public status page card, press + Create status page, give it a title, pick the sites, tunnels, or load balancers to show, and give each a display name (e.g. "Online shop", "API"). You get an address https://app.saka.work/status/<code> to share with your customers. It shows the current state and 30-day history of each service, refreshed every minute. Domains, servers, and error messages are not shown. A JSON version is at the same address with .json appended. Up to 5 pages per account.

App error alerts

For every site and app (WordPress, PHP, Git apps, ready-made apps), Saka reads the web access log. When a site answers with server errors (5xx) at least 10 times and for at least 20% of its requests within 5 minutes, you get a Telegram alert with the most affected addresses and a snippet of the app's error log (e.g. PHP Fatal error, Traceback, panic). The same warning shows on the site page. At most once an hour per site; a "back to normal" message follows after 15 minutes without a spike.

Scheduled job monitoring

Cron jobs of Git apps in Saka are monitored automatically: when a scheduled job starts failing (non-zero exit code or timeout), you get alerted with the end of its output, and again when it succeeds. Repeated failures are not re-alerted.

Other jobs (cron on any server, backup scripts, stock sync): in Settings, Scheduled job monitoring card, press + Monitor a job and enter a name and how often it runs. You get a ping address; add it to the end of your cron command:

crontab
0 2 * * * /opt/backup.sh && curl -fsS -m 10 --retry 3 https://app.saka.work/ping/<code> || curl -fsS -m 10 --retry 3 https://app.saka.work/ping/<code>/gagal

If no report arrives within the interval plus grace period, or the job calls /gagal (a POST body is stored, e.g. the error message), you get alerted; when it reports normally again, you hear it recovered. Monitoring starts after the first report. MCP: tugas_pantau_daftar, tugas_pantau_buat, tugas_pantau_hapus.

Sites in two locations

Run a copy of a WordPress, PHP, or static site on a second server (ideally in another city or provider). If the main server goes down, visitors are served by the second one automatically and the site stays up.

  1. Requirements: WordPress/PHP sites use a database in a MariaDB cluster (static sites need none). The second server is connected to Saka, has a public IP, and is not a member of that cluster. Git apps with a PostgreSQL cluster may run on cluster members (web app and database on the same VM); see Survive a VM outage.
  2. On the site page, Two locations card, press Add a second location and pick the server. The site is copied without downtime (usually a few minutes); you get a Telegram message.
  3. Last step: change the domain's DNS record to a CNAME pointing to the load balancer address shown on the card (e.g. lbxxxx.lb.saka.work). A bare domain (e.g. shop.com) can't be a CNAME at most DNS providers: use www.shop.com or a provider with CNAME flattening (e.g. Cloudflare).

Git apps in two locations

Through your AI agent: situs_lokasi_kedua. Through the API: POST /api/v1/situs/<id>/lokasi {"server_id": "..."}.

What we deliberately do not do

Security

Through your AI agent (MCP) and the API

MCP tools

ToolWhat it does
situs_daftarLists sites across all servers, with their domains and state.
situs_buatCreates a WordPress, PHP, or static site, with a local or cluster database, or moves one from cPanel (sumber with a backup file, or cpanel to sign in to the old cPanel). The agent must confirm the plan with you first.
situs_statusSite state: HTTPS and DNS for each domain, size, list of backups, SFTP account. No passwords.
situs_cadangkanMakes a backup now.
situs_atur_phpChanges the PHP settings: upload limit, memory, execution time, max_input_vars, time zone, show errors.
situs_pindah_salinFirst step of moving to another server: copies the site to the target server (optionally with another PHP version and a WordPress update). The old site keeps running.
situs_ubah_siapkanStep 1 of 2 for pulihkan (restore), hapus (delete), pindah_sekarang (move now), pindah_selesai (finish the move), or pindah_batal (cancel the move): a preview and a confirmation token (10 minutes).
situs_ubahStep 2 of 2: runs that action with the token, only after you have approved the preview.

There is no MCP tool for reading site passwords. See Connect your AI (MCP).

API endpoints

MethodPathDetails
GET/situsList sites (can be filtered with ?server_id=).
POST/situsCreate a site. Body {"nama", "server_id", "jenis", "domain", "php", "bahasa", "db", "klaster_id", "sumber", "cpanel"}.
GET/situs/{id}Details and status (DNS, HTTPS, backups, SFTP without password, pindah while a move is in progress).
PATCH/situs/{id}Change the name, domains, PHP version, or PHP settings. Body {"nama", "domain", "php", "php_ini"}.
DELETE/situs/{id}Delete. Body {"konfirmasi": "<site name>", "simpan_cadangan": true}.
POST/situs/{id}/rahasiaRead the database, SFTP, and WordPress admin passwords directly from the server.
POST/situs/{id}/cadanganBack up now.
POST/situs/{id}/pulihkanRestore. Body {"berkas": "<backup name>", "konfirmasi": "<site name>"}.
POST/situs/{id}/phpmyadminStart the site's phpMyAdmin. Returns {"url"}, a single-use sign-in link (60 seconds).
POST/situs/{id}/pindahCopy to another server. Body {"server_id", "php", "perbarui_wp"}.
POST/situs/{id}/pindah/sekarangMove now. Body {"konfirmasi": "<site name>"}.
POST/situs/{id}/pindah/selesaiFinish: delete the site on the old server (last backup kept in /root).
POST/situs/{id}/pindah/batalCancel the move; the site stays on, or goes back to, the old server.
curl
curl -s -X POST https://app.saka.work/api/v1/situs \
  -H "Authorization: Bearer $SAKA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "nama": "Toko Kue Ibu",
    "server_id": "srv_aaaaaaaaaaaaaaaa",
    "jenis": "wordpress",
    "domain": ["tokokue.id", "www.tokokue.id"],
    "php": "8.3",
    "bahasa": "en",
    "db": "lokal"
  }'

jenis (type): wordpress, php, or statis (static); a cPanel move uses php with sumber, or with cpanel: {"host", "pengguna", "sandi"}, or "token" instead of the password, plus "abaikan_tls": true for a self-signed certificate. php: 8.2, 8.3 (default), or 8.4. db: lokal (local, default) or klaster (cluster) with klaster_id. The 202 response contains the site with keadaan: "dibuat" (being created); poll GET /situs/{id} until it is siap (ready) or gagal (failed). General details are in the REST API page.

Coming soon

Coming soon

Need something else? Suggest it from the Request a feature menu in the panel (see Feature requests & migration help).