Saki Panel

A server ops panel with an agent that can see, change, and run.
High-risk work waits for your OK. Crashes get a fingerprint, a reviewed patch, and a rollback if it happens again.

English · 简体中文

Why Saki? · Saki · Watch · Panel · Quick Start · Architecture · Deploy

Saki Panel is a web console for instances, nodes, files, terminals, and permissions. Saki is not a sidebar chatbot — it reads live status, logs, metrics, and the file tree, then acts inside the same workspace.

You can tell it:

Restart the Node service on node-02 and tail the last 50 lines.
/var is filling up. Find what's using space and ask before deleting anything.
Update the Minecraft server. Back up the world first.

Local models via Ollama or LM Studio work with no API key. Cloud providers and GitHub Copilot are optional.

Why Saki Panel? (Comparison with Alternatives)

Existing tools are great at what they do: MCSManager excels at lightweight game hosting, 1Panel manages Linux web servers, Pterodactyl dominates commercial multi-tenant game hosting, and aaPanel handles traditional web stacks.

However, they all remain passive, manual tools. When a process crashes at 3 AM, they either restart it blindly into a crash loop or wait for a human to dig through thousands of lines of logs.

Dimension	MCSManager	1Panel	Pterodactyl	aaPanel	Saki Panel
AI Ops Agent	None (manual only)	Basic chatbot / App store only	None	Cloud-only external widget	In-workspace SRE agent: inspects live logs, files, CPU/RAM, and runs scoped tools
Crash Self-Healing	Blind restart loop, manual log digging	Basic Docker restart policy	Basic container restart policy	Process manager restart loop	Saki Watch: Fingerprints errors, drafts patches, waits for OK, auto-rollback on recurring crash
Local LLM & Privacy	None	Manual external container setup	None	Commercial cloud API only	Zero-config Ollama & LM Studio (100% offline & private, zero API key needed)
Safety & Guardrails	Standard RBAC	Linux/Docker permissions	Docker container sandbox	Standard root execution	4-level risk approvals, mandatory confirmation on high-risk writes, daemon-level command blockers
Supported Workloads	Processes, Docker, Game servers	Docker & Web stacks	Docker containers only	Heavy web hosting (LNMP/LAMP)	9 native types (CLI, Node, Python, JAR, Docker/Compose, plus Minecraft & Steam)
Game Server Experience	Tailored for game servers	Needs generic Docker, lacks game consoles	Dedicated game server eggs	Basic shell terminal	Native Minecraft console color parsing, Steam dedicated servers, pinpoint crash diagnosis
Cluster & Multi-Node	Panel + Daemon	Single-node by default, multi-node in enterprise	Panel + Wings (powerful)	Paid cloud central manager	Panel + Ultra-light Node Daemon, instant token pairing, zero complex networking
Setup & Complexity	Easy (Node.js)	Easy (Go + Docker)	Complex (PHP/Laravel + MySQL + Redis + Go Wings)	Easy, but modifies host environment	Simple & Fast (Fastify 5 + React 19 + SQLite, snappy & lightweight)

Summary:

If you need commercial, multi-tenant game server hosting with strict billing: Pterodactyl is the industry standard.

If you primarily need a traditional Linux web server with Nginx reverse proxies: 1Panel is solid.

If you want an AI-native server panel with a 24/7 autonomous SRE, versatile support for processes/Docker/games, and safe self-healing rollbacks: Saki Panel is built for you.

Screenshots

Dashboard — cluster overview, CPU / memory / disk, resource curves, node health, and recent audit:

Dashboard

Saki on the logs — the agent works inside the same workspace: live instance logs behind, Saki chat in front, asked to find out why a player keeps dying:

Saki reading instance logs

Saki Watch incident — a watched instance exits with code 1, the daemon fingerprints it, and diagnosis waits for your confirm:

Saki Watch incident

Saki


Context	Instance state, stdout/stderr buffers, file trees, CPU / memory / disk. No copy-paste.
Actions	Start / stop / restart, read and edit files, run commands — scoped to the workspace.
Approvals	Four risk levels. High-risk needs an explicit confirm. Critical commands are blocked in the daemon.
Skills & MCP	Recurring runbooks as Skills. External tools over MCP.
Input	Screenshots, log files, and text attachments in chat.
Guards	Detects repeated output, stuck tool loops, and runaway turns. XML, Qwen, Hermes, and native JSON tool calls.

Local, no cloud

SAKI_PROVIDER=ollama
SAKI_MODEL=llama3.2
SAKI_OLLAMA_URL=http://localhost:11434

Or pick OpenAI, Anthropic, DeepSeek, Qwen, Gemini, MiniMax, Zhipu, Moonshot, Doubao, or GitHub Copilot in Settings.

Saki Watch

When a watched instance exits unexpectedly:

Incident — Daemon records the exit and groups it by error fingerprint. No model call yet.
Confirm — You start diagnosis from the incident banner or the notification bell.
Scoped run — Agent reads logs and files. No shell, no deletes, no startup-command edits.
Review — Proposed diffs wait for you before anything is written.
Verify — Service restarts. Same crash again → files roll back to the pre-patch checkpoint.

Panel

Dashboard — Cluster overview, CPU / memory / disk, node health, recent audit.
Instances — Nine types, restart policies, logs, and process probes.
Terminal — xterm.js over WebSocket, reconnects on drop, Minecraft color codes.
Files — Browser, CodeMirror 6 editor, upload / download, zip / tar / rar / 7z in the background.
Databases — SQLite, MySQL / MariaDB, PostgreSQL, Redis. Schema, rows, and queries in the panel.
Nodes — One lightweight daemon per machine. Panel talks to them with node tokens.
Tasks — Cron for commands, restarts, and maintenance, with run history.
Access — RBAC, session timeout, login rate limits, full audit log.
Templates — Reusable start commands, env, and deploy params.

Instance types

Type	For
`generic_command`	Any CLI process
`nodejs`	Node apps and package scripts
`python`	Scripts and virtualenvs
`java_jar`	JARs and Minecraft server jars
`shell_script`	Bash / shell
`docker_container`	Single containers
`docker_compose`	Compose stacks
`minecraft`	Dedicated MC servers, console parsing
`steam_game_server`	Steam dedicated servers

Quick Start

Requires Node.js ≥ 22.13 and npm ≥ 9.

git clone https://github.com/EthanChan050430/Saki-Panel.git
cd Saki-Panel
npm install
npx prisma db push --skip-generate
npm run dev

Platform scripts under scripts/ also handle port conflicts:

OS	Script
Windows	`scripts/windows/start-dev.ps1`
Linux	`bash scripts/linux/start-dev.sh`
macOS	`scripts/macos/start-dev.command`

Service	URL
Web	http://localhost:5478
Panel API	http://localhost:5479
Daemon	http://localhost:5480

Default login: admin / admin123456

Change JWT_SECRET, ADMIN_PASSWORD, and DAEMON_REGISTRATION_TOKEN before anything is reachable from the network.

Architecture

┌──────────────┐   HTTP / WS + JWT    ┌──────────────┐   HTTP / WS + token   ┌──────────────┐
│     Web      │ ◄──────────────────► │    Panel     │ ◄──────────────────► │    Daemon    │
│  React 19    │                      │  Fastify 5   │                      │  Fastify 5   │
│  Vite 6      │                      │  Saki Agent  │                      │  Node agent  │
│  :5478       │                      │  :5479       │                      │  :5480       │
└──────────────┘                      └──────────────┘                      └──────┬───────┘
                                                                                   │ spawn
                                                                                   ▼
                                                                            ┌──────────────┐
                                                                            │  Instances   │
                                                                            └──────────────┘

Layer	Role
Web	Console and Saki chat. React 19, Vite 6, CodeMirror 6, xterm.js.
Panel	Auth, database, RBAC, audit, Saki. Fastify 5, Prisma 6, SQLite.
Daemon	Process, files, terminal, metrics on each machine.
Shared	Types and contracts.

apps/web        frontend
apps/panel      API + Saki
apps/daemon     node agent
packages/shared types
prisma/         SQLite schema

Deploy

Docker Compose

export JWT_SECRET="your-secure-random-secret"
export ADMIN_PASSWORD="your-strong-admin-password"
export DAEMON_REGISTRATION_TOKEN="your-daemon-token"

docker compose build
docker compose up -d

Split public hosts:

export PANEL_PUBLIC_URL="http://your-server-ip:5479"
export WEB_ORIGIN="http://your-server-ip:5478"
export PANEL_CORS_ORIGINS="*"
export VITE_API_BASE_URL="http://your-server-ip:5479"

docker compose build --no-cache panel web
docker compose up -d

systemd

sudo cp scripts/linux/saki-panel.service /etc/systemd/system/
sudo cp scripts/linux/saki-panel-daemon.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now saki-panel
sudo systemctl enable --now saki-panel-daemon

Commands

npm run dev          # panel + daemon + web
npm run dev:panel
npm run dev:daemon
npm run dev:web
npm run build
npm run check        # typecheck all workspaces
npm run db:push

License

Apache License 2.0. See LICENSE.

Copyright 2024-2026 DreamStarryRobot Contributors