ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
Add panel-driven cloudflared login flow
Juan Denis7d55a9c05d20
diff --git a/agent/internal/agent/agent.go b/agent/internal/agent/agent.goindex 1991a6f8..9d7a1721 100644--- a/agent/internal/agent/agent.go+++ b/agent/internal/agent/agent.go@@ -279,6 +279,7 @@ func (a *Agent) registerHandlers() {// capabilities probe, so the panel can distinguish "binary// installed but not logged in" from "not installed at all."a.handlers[protocol.ActionCloudflaredStatus] = a.handleCloudflaredStatus+ a.handlers[protocol.ActionCloudflaredLogin] = a.handleCloudflaredLogina.handlers[protocol.ActionCloudflaredTunnelList] = a.handleCloudflaredTunnelLista.handlers[protocol.ActionCloudflaredTunnelCreate] = a.handleCloudflaredTunnelCreatea.handlers[protocol.ActionCloudflaredTunnelRoute] = a.handleCloudflaredTunnelRoutediff --git a/agent/internal/agent/cloudflared_handlers.go b/agent/internal/agent/cloudflared_handlers.goindex e5827b36..624781a0 100644--- a/agent/internal/agent/cloudflared_handlers.go+++ b/agent/internal/agent/cloudflared_handlers.go@@ -6,6 +6,7 @@ import ("fmt""github.com/serverkit/agent/internal/cloudflared"+ "github.com/serverkit/agent/internal/jobs")// Handlers for cloudflared:* actions. Same shape as cron handlers:@@ -49,6 +50,82 @@ func (a *Agent) handleCloudflaredTunnelRoute(ctx context.Context, params json.Rareturn map[string]bool{"success": true}, nil}+// handleCloudflaredLogin starts `cloudflared tunnel login` and streams+// progress on a job channel. Returns {job_id, channel} immediately so+// the panel can subscribe and surface the auth URL the moment+// cloudflared prints it. The flow:+//+// 1. Agent spawns `cloudflared tunnel login` with stdout/stderr piped+// 2. First line containing https://dash.cloudflare.com/argotunnel?...+// is reported as a 'status' event with auth_url+// 3. Panel renders a clickable button; user opens URL → authorises+// 4. cloudflared writes cert.pem and exits+// 5. Agent emits 'done' with the cert path; panel can refresh+// capabilities to flip the Authenticated badge.+//+// 15-minute hard ceiling (cloudflared blocks waiting for the OAuth+// callback) — long enough for a coffee break, short enough that a+// forgotten browser tab gets reaped.+func (a *Agent) handleCloudflaredLogin(ctx context.Context, _ json.RawMessage) (interface{}, error) {+ // Use a background context for the subscription so the agent's+ // 5-minute command timeout doesn't kill the login flow.+ loginCtx := context.Background()+ ch, err := a.cloudflared.Login(loginCtx)+ if err != nil {+ return nil, fmt.Errorf("start login: %w", err)+ }+ job := a.jobs.New(64)+ go a.runCloudflaredLoginJob(job, ch)+ return map[string]interface{}{+ "job_id": job.ID,+ "channel": job.Channel,+ }, nil+}++func (a *Agent) runCloudflaredLoginJob(job *jobs.Job, events <-chan cloudflared.LoginEvent) {+ exit := 0+ emit := func(ev jobs.Event) { _ = job.Push(a.ws, ev) }+ emit(jobs.Event{Phase: jobs.PhaseStart, Message: "starting cloudflared tunnel login"})++ for ev := range events {+ switch {+ case ev.AuthURL != "":+ emit(jobs.Event{+ Phase: jobs.PhaseStatus,+ Message: "Open this URL in your browser to authorise the agent",+ Extra: map[string]interface{}{"auth_url": ev.AuthURL},+ })+ if ev.Line != "" {+ emit(jobs.Event{Phase: jobs.PhaseLog, Lines: []string{ev.Line}})+ }+ case ev.Done:+ if ev.Error != "" {+ exit = 1+ emit(jobs.Event{+ Phase: jobs.PhaseDone,+ ExitCode: &exit,+ Error: ev.Error,+ })+ } else {+ emit(jobs.Event{+ Phase: jobs.PhaseDone,+ ExitCode: &exit,+ Message: "authenticated",+ Extra: map[string]interface{}{"cert_path": ev.CertPath},+ })+ }+ case ev.Line != "":+ emit(jobs.Event{Phase: jobs.PhaseLog, Lines: []string{ev.Line}})+ }+ }+ // Channel closed without explicit Done — emit a defensive+ // terminator so the panel modal doesn't hang indefinitely.+ if !job.HasTerminated() {+ exit = 1+ emit(jobs.Event{Phase: jobs.PhaseDone, ExitCode: &exit, Error: "login stream ended unexpectedly"})+ }+}+func (a *Agent) handleCloudflaredTunnelDelete(ctx context.Context, params json.RawMessage) (interface{}, error) {var p struct {Ref string `json:"ref"`diff --git a/agent/internal/cloudflared/cloudflared.go b/agent/internal/cloudflared/cloudflared.goindex 0c2e864e..c56345c3 100644--- a/agent/internal/cloudflared/cloudflared.go+++ b/agent/internal/cloudflared/cloudflared.go@@ -69,6 +69,18 @@ type RouteRequest struct {Hostname string `json:"hostname"`}+// LoginEvent is emitted while a `cloudflared tunnel login` flow is in+// flight. AuthURL is the OAuth URL the user must open in a browser+// to authorise the agent host with their Cloudflare account; cert.pem+// is written by cloudflared once the OAuth round-trips.+type LoginEvent struct {+ AuthURL string `json:"auth_url,omitempty"`+ Line string `json:"line,omitempty"`+ Done bool `json:"done,omitempty"`+ CertPath string `json:"cert_path,omitempty"`+ Error string `json:"error,omitempty"`+}+// Manager is the platform-agnostic interface; the Linux build wires// it up with real exec calls, non-Linux builds return "unsupported."type Manager interface {@@ -77,6 +89,11 @@ type Manager interface {Create(ctx context.Context, req CreateRequest) (*Tunnel, error)Route(ctx context.Context, req RouteRequest) errorDelete(ctx context.Context, ref string) error+ // Login starts `cloudflared tunnel login` and streams events on+ // the returned channel. The first event carries the auth URL; the+ // channel closes when cert.pem is written (Done=true) or the+ // underlying process errors out.+ Login(ctx context.Context) (<-chan LoginEvent, error)}// hasCloudflared is shared between the Linux backend and tests.diff --git a/agent/internal/cloudflared/cloudflared_linux.go b/agent/internal/cloudflared/cloudflared_linux.goindex 53d30c60..844f2594 100644--- a/agent/internal/cloudflared/cloudflared_linux.go+++ b/agent/internal/cloudflared/cloudflared_linux.go@@ -3,15 +3,18 @@package cloudflaredimport (+ "bufio""bytes""context""encoding/json""fmt"+ "io""os""os/exec""path/filepath""regexp""strings"+ "time")// New returns a Linux Manager that drives `cloudflared`.@@ -170,6 +173,124 @@ func (l *linuxManager) Route(ctx context.Context, req RouteRequest) error {return err}+// loginURLRegex matches the `https://dash.cloudflare.com/argotunnel?...`+// URL cloudflared prints to stdout during `tunnel login`. The exact+// text varies by version ("Please open the following URL", "Please+// visit", etc.), so we match the URL itself rather than the prompt.+var loginURLRegex = regexp.MustCompile(`https://dash\.cloudflare\.com/argotunnel\?\S+`)++// Login spawns `cloudflared tunnel login` and streams a typed event+// channel. The first event after the URL is found carries AuthURL;+// the channel closes (with a final Done event) when cert.pem appears+// or the process exits / 15-minute hard ceiling fires.+//+// We can't just look at process exit because cloudflared sometimes+// prints the URL and exits cleanly while waiting on the OAuth callback+// in a separate flow. The cert.pem watcher is the source of truth.+func (l *linuxManager) Login(ctx context.Context) (<-chan LoginEvent, error) {+ if _, ok := hasCloudflared(); !ok {+ return nil, fmt.Errorf("cloudflared not installed")+ }+ // If cert.pem already exists, short-circuit — login would+ // overwrite, which surprises the user.+ if cert, ok := findCert(); ok {+ out := make(chan LoginEvent, 1)+ out <- LoginEvent{Done: true, CertPath: cert, Line: "already authenticated"}+ close(out)+ return out, nil+ }++ out := make(chan LoginEvent, 8)++ // 15-minute ceiling on the login flow — long enough for a coffee+ // break, short enough to garbage-collect a forgotten browser tab.+ cctx, cancel := context.WithTimeout(ctx, 15*time.Minute)++ cmd := exec.CommandContext(cctx, "cloudflared", "tunnel", "login")+ stdout, err := cmd.StdoutPipe()+ if err != nil {+ cancel()+ return nil, fmt.Errorf("stdout pipe: %w", err)+ }+ stderr, err := cmd.StderrPipe()+ if err != nil {+ cancel()+ return nil, fmt.Errorf("stderr pipe: %w", err)+ }+ if err := cmd.Start(); err != nil {+ cancel()+ return nil, fmt.Errorf("start cloudflared: %w", err)+ }++ go func() {+ defer cancel()+ defer close(out)++ // Tee stdout + stderr into a single line stream. cloudflared+ // has historically printed the auth URL on stderr (older+ // versions) and stdout (newer), so listen to both.+ lines := make(chan string, 32)+ go scanLines(stdout, lines)+ go scanLines(stderr, lines)++ urlSent := false+ // Best-effort cert.pem watcher running in parallel. cloudflared+ // itself exits as soon as the cert is fetched on success, but+ // the watcher is the more reliable signal in case of weird+ // stdout buffering.+ certCheck := time.NewTicker(2 * time.Second)+ defer certCheck.Stop()++ // Drain pipes + watch cert in the same select loop.+ for {+ select {+ case <-cctx.Done():+ out <- LoginEvent{Done: true, Error: "login timed out"}+ _ = cmd.Process.Kill()+ return+ case line, ok := <-lines:+ if !ok {+ // pipes closed — wait for cmd to reap and emit final.+ _ = cmd.Wait()+ if cert, ok := findCert(); ok {+ out <- LoginEvent{Done: true, CertPath: cert}+ } else {+ out <- LoginEvent{Done: true, Error: "cloudflared exited without writing cert.pem"}+ }+ return+ }+ if !urlSent {+ if u := loginURLRegex.FindString(line); u != "" {+ urlSent = true+ out <- LoginEvent{AuthURL: u, Line: line}+ continue+ }+ }+ out <- LoginEvent{Line: line}+ case <-certCheck.C:+ if cert, ok := findCert(); ok {+ out <- LoginEvent{Done: true, CertPath: cert}+ _ = cmd.Process.Kill()+ return+ }+ }+ }+ }()+ return out, nil+}++// scanLines pumps r line-by-line into out. Closes out when r is+// exhausted; multiple producers are fine because the consumer treats+// a single closed channel as "all done."+func scanLines(r io.ReadCloser, out chan<- string) {+ defer r.Close()+ sc := bufio.NewScanner(r)+ sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)+ for sc.Scan() {+ out <- sc.Text()+ }+}+func (l *linuxManager) Delete(ctx context.Context, ref string) error {if ref == "" {return fmt.Errorf("ref is required")diff --git a/agent/internal/cloudflared/cloudflared_other.go b/agent/internal/cloudflared/cloudflared_other.goindex 61f4a444..2bb1b071 100644--- a/agent/internal/cloudflared/cloudflared_other.go+++ b/agent/internal/cloudflared/cloudflared_other.go@@ -23,3 +23,6 @@ func (stubManager) Create(ctx context.Context, _ CreateRequest) (*Tunnel, error)}func (stubManager) Route(ctx context.Context, _ RouteRequest) error { return errUnsupported }func (stubManager) Delete(ctx context.Context, _ string) error { return errUnsupported }+func (stubManager) Login(ctx context.Context) (<-chan LoginEvent, error) {+ return nil, errUnsupported+}diff --git a/agent/internal/jobs/jobs.go b/agent/internal/jobs/jobs.goindex 0614ee35..e87b5ff2 100644--- a/agent/internal/jobs/jobs.go+++ b/agent/internal/jobs/jobs.go@@ -194,3 +194,15 @@ func (j *Job) Replay() []Event {// Done returns a channel closed when the job emits a final event with// Phase == PhaseDone. Useful for tests.func (j *Job) Done() <-chan struct{} { return j.done }++// HasTerminated reports whether a Done event has already been emitted.+// Useful for handler shutdown paths that want to avoid double-emitting+// a final terminator if their primary loop already pushed one.+func (j *Job) HasTerminated() bool {+ select {+ case <-j.done:+ return true+ default:+ return false+ }+}diff --git a/agent/pkg/protocol/messages.go b/agent/pkg/protocol/messages.goindex 118c791d..9e341ad8 100644--- a/agent/pkg/protocol/messages.go+++ b/agent/pkg/protocol/messages.go@@ -322,6 +322,7 @@ const (// `cloudflared tunnel login` (approach A from the design notes).// Status reflects "is binary installed AND has cert.pem".ActionCloudflaredStatus = "cloudflared:status"+ ActionCloudflaredLogin = "cloudflared:login"ActionCloudflaredTunnelList = "cloudflared:tunnel:list"ActionCloudflaredTunnelCreate = "cloudflared:tunnel:create"ActionCloudflaredTunnelRoute = "cloudflared:tunnel:route"diff --git a/backend/app/api/servers.py b/backend/app/api/servers.pyindex 7e85c930..c3616f09 100644--- a/backend/app/api/servers.py+++ b/backend/app/api/servers.py@@ -2269,6 +2269,18 @@ def remote_cloudflared_status(server_id):return _agent_result(result)+@servers_bp.route('/<server_id>/cloudflared/login', methods=['POST'])+@jwt_required()+@developer_required+def remote_cloudflared_login(server_id):+ """Start `cloudflared tunnel login` on the agent. Returns+ {job_id, channel}; the panel subscribes to the corresponding+ Socket.IO room and renders the auth_url the agent surfaces."""+ user_id = get_jwt_identity()+ result = RemoteCloudflaredService.login(server_id, user_id=user_id)+ return _agent_result(result)++@servers_bp.route('/<server_id>/cloudflared/tunnels', methods=['GET'])@jwt_required()def remote_cloudflared_list(server_id):diff --git a/backend/app/services/remote_cloudflared_service.py b/backend/app/services/remote_cloudflared_service.pyindex 99990f4d..67f08f31 100644--- a/backend/app/services/remote_cloudflared_service.py+++ b/backend/app/services/remote_cloudflared_service.py@@ -67,3 +67,12 @@ class RemoteCloudflaredService:params={'ref': ref},user_id=user_id, timeout=30.0,)++ @staticmethod+ def login(server_id: str, user_id: Optional[int] = None) -> Dict[str, Any]:+ # Returns {job_id, channel} immediately; the panel subscribes to+ # the matching Socket.IO room for the auth_url + completion event.+ return RemoteCloudflaredService._send(+ server_id, 'cloudflared:login',+ user_id=user_id, timeout=10.0,+ )diff --git a/frontend/src/pages/ServerDetail.jsx b/frontend/src/pages/ServerDetail.jsxindex 19051378..92f18d7a 100644--- a/frontend/src/pages/ServerDetail.jsx+++ b/frontend/src/pages/ServerDetail.jsx@@ -996,6 +996,9 @@ const CloudflaredTab = ({ serverId, serverStatus }) => {const [routeHostname, setRouteHostname] = useState('');const [routing, setRouting] = useState(false);+ // Login flow: { channel, authUrl, status: 'starting'|'awaiting'|'done'|'error', error, certPath }+ const [login, setLogin] = useState(null);+const loadStatus = useCallback(async () => {try {const s = await api.getRemoteCloudflaredStatus(serverId);@@ -1088,6 +1091,65 @@ const CloudflaredTab = ({ serverId, serverStatus }) => {}}+ // Triggers `cloudflared tunnel login` on the agent and subscribes+ // to the streaming auth flow. The first event carries the auth URL+ // we surface as a clickable button; the final event flips us back+ // to ready state once cert.pem appears.+ async function handleStartLogin() {+ try {+ const res = await api.startRemoteCloudflaredLogin(serverId);+ const channel = res?.channel || `job:${res?.job_id}`;+ setLogin({ channel, status: 'starting', authUrl: null, error: null, certPath: null });++ // Reuse the live socket service to subscribe to the+ // server_stream room. We don't open the JobProgressModal+ // because the login flow needs a different shape (a single+ // big "Open URL" CTA, not a log tail).+ const { default: socketService } = await import('../services/socket');+ if (!socketService.socket) socketService.connect();+ const sock = socketService.socket;+ if (!sock) {+ setLogin(null);+ toast.error('Socket not available');+ return;+ }+ const room = `server_${serverId}_${channel}`;+ const onStream = (msg) => {+ if (msg?.channel !== channel) return;+ const ev = msg.data || {};+ const url = ev?.extra?.auth_url;+ if (url) {+ setLogin((cur) => cur ? { ...cur, status: 'awaiting', authUrl: url } : cur);+ }+ if (ev.phase === 'done') {+ if (ev.error) {+ setLogin((cur) => cur ? { ...cur, status: 'error', error: ev.error } : cur);+ toast.error(`Login failed: ${ev.error}`);+ } else {+ setLogin((cur) => cur ? { ...cur, status: 'done', certPath: ev?.extra?.cert_path } : cur);+ toast.success('Cloudflare login complete');+ // Refresh capabilities + status so the tab unlocks+ // without a manual reload.+ api.refreshRemoteCapabilities(serverId).catch(() => {});+ loadStatus();+ loadTunnels();+ }+ sock.off('server_stream', onStream);+ sock.emit('leave_room', { room });+ }+ };+ sock.emit('join_room', { room });+ sock.on('server_stream', onStream);+ } catch (err) {+ toast.error(err.message || 'Failed to start login');+ setLogin(null);+ }+ }++ function handleCancelLogin() {+ setLogin(null);+ }+if (serverStatus !== 'online') {return (<div className="offline-notice">@@ -1139,12 +1201,19 @@ const CloudflaredTab = ({ serverId, serverStatus }) => {Cloudflare docs</a>.</>+ ) : login ? (+ <CloudflaredLoginCard login={login} onCancel={handleCancelLogin} />) : (- <>- On the server, run <code>sudo cloudflared tunnel login</code>. A browser- window will open and ask you to pick a Cloudflare zone. After that, click- Refresh here.- </>+ <div className="cloudflared-login-prompt">+ <p>+ Cloudflare needs you to authorise this agent once. Click{' '}+ <strong>Login</strong> below — we'll start the OAuth flow on the+ server and surface the URL for you to open in your browser. Once you+ authorise, the agent picks up the cert.pem automatically and the+ rest of this tab unlocks.+ </p>+ <Button onClick={handleStartLogin}>Login to Cloudflare</Button>+ </div>)}</div>)}@@ -1273,6 +1342,71 @@ const CloudflaredTab = ({ serverId, serverStatus }) => {);};+// CloudflaredLoginCard renders the in-flight OAuth login state. The+// agent has spawned `cloudflared tunnel login` on the server and is+// streaming progress on a job channel; we render either a spinner+// (while we wait for the URL), the Open-in-Browser CTA (once the URL+// arrives), or a final success/error message.+const CloudflaredLoginCard = ({ login, onCancel }) => {+ if (!login) return null;+ if (login.status === 'starting') {+ return (+ <div className="cloudflared-login-card">+ <p>Asking the agent to start the Cloudflare login flow…</p>+ <Button variant="outline" size="sm" onClick={onCancel}>Cancel</Button>+ </div>+ );+ }+ if (login.status === 'awaiting' && login.authUrl) {+ return (+ <div className="cloudflared-login-card">+ <p>+ <strong>Step 1 / 2:</strong> open the following URL in your browser, sign in+ to Cloudflare, and pick the zone you want to associate with this agent.+ </p>+ <div className="cloudflared-login-card__actions">+ <a+ href={login.authUrl}+ target="_blank"+ rel="noreferrer"+ className="btn btn-primary"+ >+ Open Cloudflare login+ </a>+ <button+ type="button"+ className="btn btn-outline"+ onClick={() => navigator.clipboard?.writeText(login.authUrl)}+ >+ Copy URL+ </button>+ </div>+ <p className="cloudflared-login-card__hint">+ <strong>Step 2 / 2:</strong> waiting for the agent to receive cert.pem from+ Cloudflare. This page will refresh automatically once authorisation completes.+ </p>+ <Button variant="outline" size="sm" onClick={onCancel}>Cancel</Button>+ </div>+ );+ }+ if (login.status === 'done') {+ return (+ <div className="cloudflared-login-card cloudflared-login-card--success">+ Authenticated. Refreshing…+ </div>+ );+ }+ if (login.status === 'error') {+ return (+ <div className="cloudflared-login-card cloudflared-login-card--error">+ <strong>Login failed:</strong> {login.error || 'unknown error'}+ <Button variant="outline" size="sm" onClick={onCancel}>Dismiss</Button>+ </div>+ );+ }+ return null;+};+const MetricsTab = ({ serverId, metrics }) => {const formatBytes = (bytes) => {if (!bytes) return 'N/A';diff --git a/frontend/src/services/api/servers.js b/frontend/src/services/api/servers.jsindex ee4c61eb..84cac707 100644--- a/frontend/src/services/api/servers.js+++ b/frontend/src/services/api/servers.js@@ -370,6 +370,15 @@ export async function getRemoteCloudflaredStatus(serverId) {return this.request(`/servers/${serverId}/cloudflared/status`);}+// Triggers `cloudflared tunnel login` on the agent. Returns+// {job_id, channel}; subscribe via JobProgressModal to receive the+// auth URL, then watch for the done event when cert.pem lands.+export async function startRemoteCloudflaredLogin(serverId) {+ return this.request(`/servers/${serverId}/cloudflared/login`, {+ method: 'POST'+ });+}+export async function getRemoteCloudflaredTunnels(serverId) {return this.request(`/servers/${serverId}/cloudflared/tunnels`);}diff --git a/frontend/src/styles/pages/_server-packages.scss b/frontend/src/styles/pages/_server-packages.scssindex 328028d0..8b6b68db 100644--- a/frontend/src/styles/pages/_server-packages.scss+++ b/frontend/src/styles/pages/_server-packages.scss@@ -228,6 +228,47 @@}}+// Cloudflared login flow: surfaces the auth URL the agent captures+// from `cloudflared tunnel login` so the user can authorise from+// their own browser.+.cloudflared-login-prompt {+ p {+ margin: 0 0 0.75rem;+ }+}++.cloudflared-login-card {+ padding: 1rem;+ border: 1px solid var(--border);+ border-radius: 0.5rem;+ background: var(--card);+ display: flex;+ flex-direction: column;+ gap: 0.75rem;++ &--success {+ border-color: var(--success, #16a34a);+ background: color-mix(in srgb, var(--success, #16a34a) 8%, transparent);+ }++ &--error {+ border-color: var(--destructive, #ef4444);+ background: color-mix(in srgb, var(--destructive, #ef4444) 8%, transparent);+ }++ &__actions {+ display: flex;+ gap: 0.5rem;+ flex-wrap: wrap;+ }++ &__hint {+ font-size: 0.85rem;+ color: var(--muted-foreground);+ margin: 0;+ }+}+// Shared by JobProgressModal — kept here because Packages is its primary// consumer. Services tab logs use a different component path..job-progress-modal {