Skip to content

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.

Add deployment jobs and remote deployment runner

Juan Deniscc1151d0ce0b
diff --git a/agent/internal/agent/agent.go b/agent/internal/agent/agent.go
index 9236bb97..9cb2a903 100644
--- a/agent/internal/agent/agent.go
+++ b/agent/internal/agent/agent.go
@@ -11,6 +11,9 @@ import (
"fmt"
"net"
"os"
+ "path/filepath"
+ "runtime"
+ "strings"
"sync"
"time"
@@ -812,6 +815,9 @@ func (a *Agent) handleFileRead(ctx context.Context, params json.RawMessage) (int
if p.Path == "" {
return nil, fmt.Errorf("path is required")
}
+ if err := a.validateFileAccess(p.Path); err != nil {
+ return nil, err
+ }
data, err := os.ReadFile(p.Path)
if err != nil {
@@ -827,9 +833,10 @@ func (a *Agent) handleFileRead(ctx context.Context, params json.RawMessage) (int
func (a *Agent) handleFileWrite(ctx context.Context, params json.RawMessage) (interface{}, error) {
var p struct {
- Path string `json:"path"`
- Content string `json:"content"` // base64 encoded
- Mode uint32 `json:"mode"`
+ Path string `json:"path"`
+ Content string `json:"content"` // base64 encoded
+ Mode uint32 `json:"mode"`
+ CreateDirs bool `json:"create_dirs"`
}
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
@@ -837,6 +844,9 @@ func (a *Agent) handleFileWrite(ctx context.Context, params json.RawMessage) (in
if p.Path == "" {
return nil, fmt.Errorf("path is required")
}
+ if err := a.validateFileAccess(p.Path); err != nil {
+ return nil, err
+ }
data, err := base64.StdEncoding.DecodeString(p.Content)
if err != nil {
@@ -848,6 +858,12 @@ func (a *Agent) handleFileWrite(ctx context.Context, params json.RawMessage) (in
mode = os.FileMode(p.Mode)
}
+ if p.CreateDirs {
+ if err := os.MkdirAll(filepath.Dir(p.Path), 0755); err != nil {
+ return nil, fmt.Errorf("failed to create parent directories: %w", err)
+ }
+ }
+
if err := os.WriteFile(p.Path, data, mode); err != nil {
return nil, fmt.Errorf("failed to write file: %w", err)
}
@@ -869,6 +885,9 @@ func (a *Agent) handleFileList(ctx context.Context, params json.RawMessage) (int
if p.Path == "" {
p.Path = "/"
}
+ if err := a.validateFileAccess(p.Path); err != nil {
+ return nil, err
+ }
entries, err := os.ReadDir(p.Path)
if err != nil {
@@ -895,6 +914,48 @@ func (a *Agent) handleFileList(ctx context.Context, params json.RawMessage) (int
}, nil
}
+func (a *Agent) validateFileAccess(path string) error {
+ allowedPaths := a.cfg.Security.AllowedPaths
+ if len(allowedPaths) == 0 {
+ return fmt.Errorf("file access denied: no allowed_paths configured")
+ }
+
+ target, err := filepath.Abs(filepath.Clean(path))
+ if err != nil {
+ return fmt.Errorf("invalid path: %w", err)
+ }
+
+ for _, allowedPath := range allowedPaths {
+ if strings.TrimSpace(allowedPath) == "" {
+ continue
+ }
+ allowed, err := filepath.Abs(filepath.Clean(allowedPath))
+ if err != nil {
+ continue
+ }
+
+ if pathWithinAllowedRoot(target, allowed) {
+ return nil
+ }
+ }
+
+ return fmt.Errorf("file access denied for path: %s", path)
+}
+
+func pathWithinAllowedRoot(target, allowed string) bool {
+ if runtime.GOOS == "windows" {
+ target = strings.ToLower(target)
+ allowed = strings.ToLower(allowed)
+ }
+
+ if target == allowed {
+ return true
+ }
+
+ allowedWithSeparator := strings.TrimRight(allowed, string(os.PathSeparator)) + string(os.PathSeparator)
+ return strings.HasPrefix(target, allowedWithSeparator)
+}
+
// Docker Compose command handlers
func (a *Agent) handleDockerComposeList(ctx context.Context, params json.RawMessage) (interface{}, error) {
@@ -908,6 +969,9 @@ func (a *Agent) handleDockerComposePs(ctx context.Context, params json.RawMessag
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
return a.docker.ComposePsProject(ctx, p.ProjectPath)
}
@@ -920,6 +984,9 @@ func (a *Agent) handleDockerComposeUp(ctx context.Context, params json.RawMessag
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
// Default to detached mode
if !p.Detach {
@@ -950,6 +1017,9 @@ func (a *Agent) handleDockerComposeDown(ctx context.Context, params json.RawMess
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
output, err := a.docker.ComposeDown(ctx, p.ProjectPath, p.Volumes, p.RemoveOrphans)
if err != nil {
@@ -975,6 +1045,9 @@ func (a *Agent) handleDockerComposeLogs(ctx context.Context, params json.RawMess
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
// Default tail to 100
if p.Tail == 0 {
@@ -999,6 +1072,9 @@ func (a *Agent) handleDockerComposeRestart(ctx context.Context, params json.RawM
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
output, err := a.docker.ComposeRestart(ctx, p.ProjectPath, p.Service)
if err != nil {
@@ -1023,6 +1099,9 @@ func (a *Agent) handleDockerComposePull(ctx context.Context, params json.RawMess
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("invalid params: %w", err)
}
+ if err := a.validateFileAccess(p.ProjectPath); err != nil {
+ return nil, err
+ }
output, err := a.docker.ComposePull(ctx, p.ProjectPath, p.Service)
if err != nil {
diff --git a/agent/internal/config/config.go b/agent/internal/config/config.go
index bb6ef6bf..6f280256 100644
--- a/agent/internal/config/config.go
+++ b/agent/internal/config/config.go
@@ -122,7 +122,7 @@ func Default() *Config {
Docker: true,
Metrics: true,
Logs: true,
- FileAccess: false,
+ FileAccess: true,
Exec: false,
},
Metrics: MetricsConfig{
@@ -136,7 +136,7 @@ func Default() *Config {
Timeout: 30 * time.Second,
},
Security: SecurityConfig{
- AllowedPaths: []string{},
+ AllowedPaths: defaultAllowedPaths(),
BlockedCommands: []string{},
MaxExecTimeout: 5 * time.Minute,
},
@@ -328,6 +328,13 @@ func defaultLogPath() string {
return "/var/log/serverkit-agent/agent.log"
}
+func defaultAllowedPaths() []string {
+ if runtime.GOOS == "windows" {
+ return []string{filepath.Join(os.Getenv("ProgramData"), "ServerKit")}
+ }
+ return []string{"/var/lib/serverkit", "/var/serverkit"}
+}
+
// getMachineKey generates a machine-specific encryption key
func getMachineKey() []byte {
// Use machine-specific data to derive key
diff --git a/agent/scripts/install.sh b/agent/scripts/install.sh
index 872b1b1e..6dd4f97a 100644
--- a/agent/scripts/install.sh
+++ b/agent/scripts/install.sh
@@ -191,7 +191,11 @@ install_agent() {
# Create directories
mkdir -p "$CONFIG_DIR"
mkdir -p "$LOG_DIR"
+ mkdir -p /var/lib/serverkit/apps
+ mkdir -p /var/serverkit/apps
chown "$SERVICE_USER:$SERVICE_USER" "$LOG_DIR"
+ chown -R "$SERVICE_USER:$SERVICE_USER" /var/lib/serverkit
+ chown -R "$SERVICE_USER:$SERVICE_USER" /var/serverkit
}
# Register with ServerKit
@@ -242,7 +246,7 @@ SyslogIdentifier=serverkit-agent
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
-ReadWritePaths=$LOG_DIR $CONFIG_DIR
+ReadWritePaths=$LOG_DIR $CONFIG_DIR /var/lib/serverkit /var/serverkit
PrivateTmp=yes
[Install]
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index d4b7d856..21f87ac0 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -142,9 +142,11 @@ def create_app(config_name=None):
from app.api.deploy import deploy_bp
app.register_blueprint(deploy_bp, url_prefix='/api/v1/deploy')
- # Register blueprints - Builds & Deployments
- from app.api.builds import builds_bp
- app.register_blueprint(builds_bp, url_prefix='/api/v1/builds')
+ # Register blueprints - Builds & Deployments
+ from app.api.builds import builds_bp
+ from app.api.deployment_jobs import deployment_jobs_bp
+ app.register_blueprint(builds_bp, url_prefix='/api/v1/builds')
+ app.register_blueprint(deployment_jobs_bp, url_prefix='/api/v1/deployment-jobs')
# Register blueprints - Templates
from app.api.templates import templates_bp
diff --git a/backend/app/api/apps.py b/backend/app/api/apps.py
index 97cc52b4..56377467 100644
--- a/backend/app/api/apps.py
+++ b/backend/app/api/apps.py
@@ -5,12 +5,31 @@ from flask_jwt_extended import jwt_required, get_jwt_identity
from app import db
from app.models import Application, User
from app.services.docker_service import DockerService
+from app.services.remote_docker_service import RemoteDockerService
from app.services.log_service import LogService
from app import paths
apps_bp = Blueprint('apps', __name__)
+def _compose_target(app):
+ if app.server_id and app.root_path:
+ return os.path.join(app.root_path, 'docker-compose.yml')
+ return app.root_path
+
+
+def _agent_result_failed(result):
+ data = result.get('data') if isinstance(result, dict) else None
+ return isinstance(data, dict) and data.get('success') is False
+
+
+def _agent_result_error(result, fallback):
+ data = result.get('data') if isinstance(result, dict) else None
+ if isinstance(data, dict):
+ return data.get('error') or result.get('error') or fallback
+ return result.get('error') or fallback
+
+
# ==================== ENVIRONMENT LINKING ====================
@apps_bp.route('/<int:app_id>/link', methods=['POST'])
@@ -425,9 +444,17 @@ def start_app(app_id):
# Handle Docker apps
if app.app_type == 'docker' and app.root_path:
- result = DockerService.compose_up(app.root_path, detach=True)
- if not result.get('success'):
- return jsonify({'error': result.get('error', 'Failed to start containers')}), 400
+ if app.server_id:
+ result = RemoteDockerService.compose_up(
+ app.server_id,
+ _compose_target(app),
+ detach=True,
+ user_id=current_user_id
+ )
+ else:
+ result = DockerService.compose_up(app.root_path, detach=True)
+ if not result.get('success') or _agent_result_failed(result):
+ return jsonify({'error': _agent_result_error(result, 'Failed to start containers')}), 400
app.status = 'running'
db.session.commit()
@@ -453,9 +480,16 @@ def stop_app(app_id):
# Handle Docker apps
if app.app_type == 'docker' and app.root_path:
- result = DockerService.compose_down(app.root_path)
- if not result.get('success'):
- return jsonify({'error': result.get('error', 'Failed to stop containers')}), 400
+ if app.server_id:
+ result = RemoteDockerService.compose_down(
+ app.server_id,
+ _compose_target(app),
+ user_id=current_user_id
+ )
+ else:
+ result = DockerService.compose_down(app.root_path)
+ if not result.get('success') or _agent_result_failed(result):
+ return jsonify({'error': _agent_result_error(result, 'Failed to stop containers')}), 400
app.status = 'stopped'
db.session.commit()
@@ -481,9 +515,16 @@ def restart_app(app_id):
# Handle Docker apps
if app.app_type == 'docker' and app.root_path:
- result = DockerService.compose_restart(app.root_path)
- if not result.get('success'):
- return jsonify({'error': result.get('error', 'Failed to restart containers')}), 400
+ if app.server_id:
+ result = RemoteDockerService.compose_restart(
+ app.server_id,
+ _compose_target(app),
+ user_id=current_user_id
+ )
+ else:
+ result = DockerService.compose_restart(app.root_path)
+ if not result.get('success') or _agent_result_failed(result):
+ return jsonify({'error': _agent_result_error(result, 'Failed to restart containers')}), 400
app.status = 'running'
db.session.commit()
@@ -513,6 +554,15 @@ def get_app_logs(app_id):
# For Docker apps, get docker compose logs
if app.app_type == 'docker' and app.root_path:
+ if app.server_id:
+ result = RemoteDockerService.compose_logs(
+ app.server_id,
+ _compose_target(app),
+ tail=lines,
+ user_id=current_user_id
+ )
+ return jsonify(result.get('data') if result.get('success') else result), 200 if result.get('success') else 400
+
result = LogService.get_docker_app_logs(app.name, app.root_path, lines)
return jsonify(result), 200 if result.get('success') else 400
@@ -684,7 +734,17 @@ def get_app_status(app_id):
if app.app_type == 'docker' and app.root_path:
# Get container status from Docker
- containers = DockerService.compose_ps(app.root_path)
+ if app.server_id:
+ result = RemoteDockerService.compose_ps(
+ app.server_id,
+ _compose_target(app),
+ user_id=current_user_id
+ )
+ if not result.get('success'):
+ return jsonify(result), 503 if result.get('code') == 'AGENT_OFFLINE' else 400
+ containers = result.get('data', [])
+ else:
+ containers = DockerService.compose_ps(app.root_path)
# Determine overall status
running_count = sum(1 for c in containers if c.get('Status', c.get('status', '')).startswith('Up'))
@@ -706,7 +766,7 @@ def get_app_status(app_id):
# Check port accessibility
port_status = None
- if app.port:
+ if app.port and not app.server_id:
port_status = DockerService.check_port_accessible(app.port)
return jsonify({
diff --git a/backend/app/api/deployment_jobs.py b/backend/app/api/deployment_jobs.py
new file mode 100644
index 00000000..55e0759e
--- /dev/null
+++ b/backend/app/api/deployment_jobs.py
@@ -0,0 +1,49 @@
+"""Deployment job API endpoints."""
+
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+
+from app.models.deployment_job import DeploymentJob, DeploymentJobLog
+from app.services.deployment_job_service import DeploymentJobService
+
+deployment_jobs_bp = Blueprint('deployment_jobs', __name__)
+
+
+@deployment_jobs_bp.route('', methods=['GET'])
+@jwt_required()
+def list_deployment_jobs():
+ status = request.args.get('status')
+ target_server_id = request.args.get('server_id')
+ limit = request.args.get('limit', 50, type=int)
+ jobs = DeploymentJobService.list_jobs(
+ status=status,
+ target_server_id=target_server_id,
+ limit=min(limit, 200),
+ )
+ return jsonify({'jobs': jobs}), 200
+
+
+@deployment_jobs_bp.route('/<job_id>', methods=['GET'])
+@jwt_required()
+def get_deployment_job(job_id):
+ include_logs = request.args.get('logs', 'true').lower() == 'true'
+ job = DeploymentJobService.get_job(job_id, include_logs=include_logs)
+ if not job:
+ return jsonify({'error': 'Deployment job not found'}), 404
+ return jsonify({'job': job}), 200
+
+
+@deployment_jobs_bp.route('/<job_id>/logs', methods=['GET'])
+@jwt_required()
+def get_deployment_job_logs(job_id):
+ job = DeploymentJob.query.get(job_id)
+ if not job:
+ return jsonify({'error': 'Deployment job not found'}), 404
+
+ after_id = request.args.get('after_id', type=int)
+ query = DeploymentJobLog.query.filter_by(job_id=job_id)
+ if after_id:
+ query = query.filter(DeploymentJobLog.id > after_id)
+
+ logs = query.order_by(DeploymentJobLog.created_at.asc()).all()
+ return jsonify({'logs': [log.to_dict() for log in logs]}), 200
diff --git a/backend/app/api/servers.py b/backend/app/api/servers.py
index 533dc000..1f5702ae 100644
--- a/backend/app/api/servers.py
+++ b/backend/app/api/servers.py
@@ -76,6 +76,22 @@ PERMISSION_PROFILES = {
'system:logs:read',
]
},
+ 'deployment_runner': {
+ 'name': 'Deployment Runner',
+ 'description': 'Deploy and operate ServerKit-managed Docker Compose apps',
+ 'permissions': [
+ 'docker:container:*',
+ 'docker:image:*',
+ 'docker:compose:*',
+ 'docker:volume:*',
+ 'docker:network:*',
+ 'file:read',
+ 'file:write',
+ 'file:list',
+ 'system:metrics:read',
+ 'system:logs:read',
+ ]
+ },
'full_access': {
'name': 'Full Access',
'description': 'All permissions including system commands',
diff --git a/backend/app/api/templates.py b/backend/app/api/templates.py
index 2bb8cc20..dc73328e 100644
--- a/backend/app/api/templates.py
+++ b/backend/app/api/templates.py
@@ -11,6 +11,7 @@ Provides REST endpoints for:
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from app.models import User, Application
+from app.services.deployment_job_service import DeploymentJobService
from app.services.template_service import TemplateService
templates_bp = Blueprint('templates', __name__)
@@ -151,15 +152,23 @@ def install_template(template_id):
}), 400
user_variables = data.get('variables', {})
+ server_id = data.get('server_id') or data.get('target_server_id')
+ wait = bool(data.get('wait', False))
- result = TemplateService.install_template(
+ result = DeploymentJobService.install_template(
template_id=template_id,
app_name=app_name,
user_variables=user_variables,
- user_id=current_user_id
+ user_id=current_user_id,
+ server_id=server_id,
+ wait=wait,
)
- return jsonify(result), 201 if result.get('success') else 400
+ if not result.get('success'):
+ return jsonify(result), 400
+
+ status = result.get('job', {}).get('status')
+ return jsonify(result), 201 if status == 'succeeded' else 202
except Exception as e:
import traceback
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index a6fea628..bb7d20f3 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -3,7 +3,8 @@ from app.models.application import Application
from app.models.domain import Domain
from app.models.env_variable import EnvironmentVariable, EnvironmentVariableHistory
from app.models.notification_preferences import NotificationPreferences
-from app.models.deployment import Deployment, DeploymentDiff
+from app.models.deployment import Deployment, DeploymentDiff
+from app.models.deployment_job import DeploymentJob, DeploymentJobLog
from app.models.system_settings import SystemSettings
from app.models.audit_log import AuditLog
from app.models.metrics_history import MetricsHistory
@@ -32,7 +33,7 @@ from app.models.marketplace import Extension, ExtensionInstall
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
- 'NotificationPreferences', 'Deployment', 'DeploymentDiff', 'SystemSettings', 'AuditLog',
+ 'NotificationPreferences', 'Deployment', 'DeploymentDiff', 'DeploymentJob', 'DeploymentJobLog', 'SystemSettings', 'AuditLog',
'MetricsHistory', 'Workflow', 'WorkflowExecution', 'WorkflowLog', 'GitWebhook', 'WebhookLog', 'GitDeployment',
'Server', 'ServerGroup', 'ServerMetrics', 'ServerCommand', 'AgentSession', 'AgentVersion', 'AgentRollout', 'SecurityAlert',
'WordPressSite', 'DatabaseSnapshot', 'SyncJob',
diff --git a/backend/app/models/application.py b/backend/app/models/application.py
index 51c9f122..8b35630c 100644
--- a/backend/app/models/application.py
+++ b/backend/app/models/application.py
@@ -36,11 +36,13 @@ class Application(db.Model):
# Foreign keys
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+ server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=True, index=True)
# Relationships
# Use 'subquery' to eagerly load domains in a single query, avoiding N+1
domains = db.relationship('Domain', backref='application', lazy='subquery', cascade='all, delete-orphan')
linked_app = db.relationship('Application', remote_side=[id], backref='linked_from', foreign_keys=[linked_app_id])
+ server = db.relationship('Server', backref=db.backref('applications', lazy='dynamic'))
def to_dict(self, include_linked=False):
import json
@@ -65,6 +67,8 @@ class Application(db.Model):
'updated_at': self.updated_at.isoformat(),
'last_deployed_at': self.last_deployed_at.isoformat() if self.last_deployed_at else None,
'user_id': self.user_id,
+ 'server_id': self.server_id,
+ 'server_name': self.server.name if self.server else 'Local server',
'domains': [d.to_dict() for d in self.domains]
}
if include_linked and self.linked_app:
diff --git a/backend/app/models/deployment_job.py b/backend/app/models/deployment_job.py
new file mode 100644
index 00000000..570626db
--- /dev/null
+++ b/backend/app/models/deployment_job.py
@@ -0,0 +1,145 @@
+"""Deployment job models.
+
+Tracks cross-server deployment work independently from versioned app deploys.
+"""
+
+from datetime import datetime
+import json
+
+from app import db
+
+
+class DeploymentJob(db.Model):
+ """A runnable deployment job with status, target, plan, and result."""
+
+ __tablename__ = 'deployment_jobs'
+
+ id = db.Column(db.String(36), primary_key=True)
+ kind = db.Column(db.String(50), nullable=False, index=True)
+ status = db.Column(db.String(20), default='pending', nullable=False, index=True)
+
+ # Target
+ target_server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=True, index=True)
+ app_id = db.Column(db.Integer, db.ForeignKey('applications.id'), nullable=True, index=True)
+ requested_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+ trigger = db.Column(db.String(30), default='manual')
+
+ # Execution progress
+ total_steps = db.Column(db.Integer, default=0)
+ current_step = db.Column(db.Integer, default=0)
+ current_step_name = db.Column(db.String(200), nullable=True)
+
+ # Serialized plan/result
+ plan = db.Column(db.Text, default='{}')
+ result = db.Column(db.Text, default='{}')
+ error_message = db.Column(db.Text, nullable=True)
+
+ created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)
+ started_at = db.Column(db.DateTime, nullable=True)
+ completed_at = db.Column(db.DateTime, nullable=True)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ target_server = db.relationship('Server', backref=db.backref('deployment_jobs', lazy='dynamic'))
+ app = db.relationship('Application', backref=db.backref('deployment_jobs', lazy='dynamic'))
+ requester = db.relationship('User', backref=db.backref('deployment_jobs', lazy='dynamic'))
+ logs = db.relationship(
+ 'DeploymentJobLog',
+ back_populates='job',
+ lazy='dynamic',
+ cascade='all, delete-orphan',
+ order_by='DeploymentJobLog.created_at',
+ )
+
+ def get_plan(self):
+ try:
+ return json.loads(self.plan) if self.plan else {}
+ except (TypeError, json.JSONDecodeError):
+ return {}
+
+ def set_plan(self, plan):
+ self.plan = json.dumps(plan)
+ steps = plan.get('steps', []) if isinstance(plan, dict) else []
+ self.total_steps = len(steps)
+
+ def get_result(self):
+ try:
+ return json.loads(self.result) if self.result else {}
+ except (TypeError, json.JSONDecodeError):
+ return {}
+
+ def set_result(self, result):
+ self.result = json.dumps(result or {})
+
+ @property
+ def duration(self):
+ if self.started_at and self.completed_at:
+ return (self.completed_at - self.started_at).total_seconds()
+ return None
+
+ @property
+ def progress_percent(self):
+ if not self.total_steps:
+ return 0
+ return min(100, int((self.current_step / self.total_steps) * 100))
+
+ def to_dict(self, include_plan=False, include_logs=False):
+ data = {
+ 'id': self.id,
+ 'kind': self.kind,
+ 'status': self.status,
+ 'target_server_id': self.target_server_id,
+ 'target_server_name': self.target_server.name if self.target_server else 'Local server',
+ 'app_id': self.app_id,
+ 'app_name': self.app.name if self.app else None,
+ 'requested_by': self.requested_by,
+ 'trigger': self.trigger,
+ 'total_steps': self.total_steps,
+ 'current_step': self.current_step,
+ 'current_step_name': self.current_step_name,
+ 'progress_percent': self.progress_percent,
+ 'result': self.get_result(),
+ 'error_message': self.error_message,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'started_at': self.started_at.isoformat() if self.started_at else None,
+ 'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ 'duration': self.duration,
+ }
+ if include_plan:
+ data['plan'] = self.get_plan()
+ if include_logs:
+ data['logs'] = [log.to_dict() for log in self.logs.all()]
+ return data
+
+
+class DeploymentJobLog(db.Model):
+ """A timestamped deployment job log entry."""
+
+ __tablename__ = 'deployment_job_logs'
+
+ id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+ job_id = db.Column(db.String(36), db.ForeignKey('deployment_jobs.id'), nullable=False, index=True)
+ step_index = db.Column(db.Integer, nullable=True)
+ level = db.Column(db.String(10), default='info')
+ message = db.Column(db.Text, nullable=False)
+ data = db.Column(db.Text, nullable=True)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)
+
+ job = db.relationship('DeploymentJob', back_populates='logs')
+
+ def get_data(self):
+ try:
+ return json.loads(self.data) if self.data else None
+ except (TypeError, json.JSONDecodeError):
+ return None
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'job_id': self.job_id,
+ 'step_index': self.step_index,
+ 'level': self.level,
+ 'message': self.message,
+ 'data': self.get_data(),
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
diff --git a/backend/app/services/deployment_job_service.py b/backend/app/services/deployment_job_service.py
new file mode 100644
index 00000000..bcb4c1d7
--- /dev/null
+++ b/backend/app/services/deployment_job_service.py
@@ -0,0 +1,199 @@
+"""Deployment job orchestration service."""
+
+import os
+import threading
+import uuid
+from datetime import datetime
+from typing import Dict, Optional
+
+from flask import current_app, has_app_context
+
+from app import db
+from app.models import Application, Server
+from app.models.deployment_job import DeploymentJob
+from app.services.deployment_runner import DeploymentPlanRunner
+from app.services.docker_service import DockerService
+from app.services.template_service import TemplateService
+
+
+class DeploymentJobService:
+ """Creates and runs deployment jobs with persistent logs."""
+
+ @classmethod
+ def install_template(
+ cls,
+ template_id: str,
+ app_name: str,
+ user_variables: Dict = None,
+ user_id: int = None,
+ server_id: Optional[str] = None,
+ wait: bool = False,
+ ) -> Dict:
+ """Create a template installation job and optionally run it synchronously."""
+ normalized_server_id = cls._normalize_server_id(server_id)
+
+ existing = Application.query.filter_by(name=app_name, server_id=normalized_server_id).first()
+ if existing:
+ return {
+ 'success': False,
+ 'error': f'An application named "{app_name}" already exists on this target server'
+ }
+
+ if normalized_server_id:
+ server = Server.query.get(normalized_server_id)
+ if not server:
+ return {'success': False, 'error': 'Target server not found'}
+
+ plan_result = TemplateService.build_install_plan(
+ template_id=template_id,
+ app_name=app_name,
+ user_variables=user_variables or {},
+ user_id=user_id,
+ server_id=normalized_server_id,
+ )
+ if not plan_result.get('success'):
+ return plan_result
+
+ app_path = plan_result['app_path']
+ if not normalized_server_id and os.path.exists(app_path):
+ return {'success': False, 'error': f"App directory already exists: {app_path}"}
+
+ job = DeploymentJob(
+ id=str(uuid.uuid4()),
+ kind='template_install',
+ status='pending',
+ target_server_id=normalized_server_id,
+ requested_by=user_id,
+ trigger='manual',
+ )
+ job.set_plan(plan_result['plan'])
+ db.session.add(job)
+ db.session.commit()
+
+ if wait:
+ cls.run_job(job.id)
+ else:
+ cls._start_background_job(job.id)
+
+ return {
+ 'success': True,
+ 'job_id': job.id,
+ 'job': job.to_dict(include_logs=True),
+ }
+
+ @classmethod
+ def run_job(cls, job_id: str) -> Dict:
+ """Run a job by ID."""
+ job = DeploymentJob.query.get(job_id)
+ if not job:
+ return {'success': False, 'error': 'Deployment job not found'}
+
+ if job.kind != 'template_install':
+ return {'success': False, 'error': f'Unsupported deployment job kind: {job.kind}'}
+
+ runner = DeploymentPlanRunner(job)
+ run_result = runner.run()
+
+ if not run_result.get('success'):
+ return run_result
+
+ try:
+ return cls._finalize_template_install(job)
+ except Exception as exc:
+ job.status = 'failed'
+ job.error_message = str(exc)
+ job.completed_at = datetime.utcnow()
+ db.session.commit()
+ runner.log('error', f'Failed to finalize deployment: {exc}')
+ return {'success': False, 'error': str(exc)}
+
+ @classmethod
+ def get_job(cls, job_id: str, include_logs: bool = True) -> Optional[Dict]:
+ job = DeploymentJob.query.get(job_id)
+ return job.to_dict(include_logs=include_logs) if job else None
+
+ @classmethod
+ def list_jobs(cls, status: str = None, target_server_id: str = None, limit: int = 50):
+ query = DeploymentJob.query.order_by(DeploymentJob.created_at.desc())
+ if status:
+ query = query.filter_by(status=status)
+ if target_server_id:
+ query = query.filter_by(target_server_id=cls._normalize_server_id(target_server_id))
+ return [job.to_dict() for job in query.limit(limit).all()]
+
+ @classmethod
+ def _finalize_template_install(cls, job: DeploymentJob) -> Dict:
+ plan = job.get_plan()
+ app_name = plan.get('app_name')
+ app_path = plan.get('app_path')
+ app_port = plan.get('port')
+ template_name = plan.get('template_name')
+
+ app = Application(
+ name=app_name,
+ app_type='docker',
+ status='running',
+ root_path=app_path,
+ docker_image=template_name,
+ user_id=job.requested_by or 1,
+ port=app_port,
+ server_id=job.target_server_id,
+ )
+ db.session.add(app)
+ db.session.commit()
+
+ port_accessible = None
+ if not job.target_server_id and app_port:
+ port_accessible = DockerService.check_port_accessible(app_port).get('accessible', False)
+
+ config = TemplateService.get_config()
+ config.setdefault('installed', {})[str(app.id)] = {
+ 'template_id': plan.get('template_id'),
+ 'template_version': plan.get('template_version'),
+ 'app_id': app.id,
+ 'app_name': app_name,
+ 'server_id': job.target_server_id,
+ 'installed_at': datetime.utcnow().isoformat(),
+ }
+ TemplateService.save_config(config)
+
+ result = {
+ 'success': True,
+ 'app_id': app.id,
+ 'app_name': app.name,
+ 'app_path': app_path,
+ 'server_id': job.target_server_id,
+ 'port': app_port,
+ 'port_accessible': port_accessible,
+ }
+
+ job.app_id = app.id
+ job.set_result({**job.get_result(), **result})
+ db.session.commit()
+
+ DeploymentPlanRunner(job).log('info', f'Application record created: {app.name}', result)
+
+ return {'success': True, 'job': job.to_dict(include_logs=True), **result}
+
+ @classmethod
+ def _start_background_job(cls, job_id: str):
+ flask_app = current_app._get_current_object() if has_app_context() else None
+
+ def _target():
+ if flask_app:
+ with flask_app.app_context():
+ cls.run_job(job_id)
+ else:
+ from app import create_app
+ app = create_app()
+ with app.app_context():
+ cls.run_job(job_id)
+
+ thread = threading.Thread(target=_target, daemon=True)
+ thread.start()
+
+ @staticmethod
+ def _normalize_server_id(server_id: Optional[str]) -> Optional[str]:
+ if not server_id or server_id == 'local':
+ return None
+ return server_id
diff --git a/backend/app/services/deployment_runner.py b/backend/app/services/deployment_runner.py
new file mode 100644
index 00000000..d34bf3de
--- /dev/null
+++ b/backend/app/services/deployment_runner.py
@@ -0,0 +1,240 @@
+"""Shared deployment plan runner.
+
+Executes the same deployment plan against the local server or a connected agent.
+"""
+
+import base64
+import json
+import os
+import time
+from datetime import datetime
+from typing import Any, Dict
+
+from app import db
+from app.models.deployment_job import DeploymentJob, DeploymentJobLog
+from app.services.agent_registry import agent_registry
+from app.services.docker_service import DockerService
+
+
+class DeploymentStepError(Exception):
+ """Raised when a deployment step fails."""
+
+
+class DeploymentPlanRunner:
+ """Run deployment steps and persist job status/logs."""
+
+ def __init__(self, job: DeploymentJob):
+ self.job = job
+
+ @property
+ def is_remote(self) -> bool:
+ return bool(self.job.target_server_id)
+
+ def run(self) -> Dict[str, Any]:
+ plan = self.job.get_plan()
+ steps = plan.get('steps', [])
+ results = []
+
+ self.job.status = 'running'
+ self.job.started_at = datetime.utcnow()
+ self.job.total_steps = len(steps)
+ db.session.commit()
+
+ self.log('info', f"Deployment started on {self.job.target_server_name}")
+
+ try:
+ for index, step in enumerate(steps, start=1):
+ name = step.get('name') or step.get('type') or f"Step {index}"
+ self.job.current_step = index
+ self.job.current_step_name = name
+ db.session.commit()
+
+ self.log('info', name, step_index=index)
+ result = self._execute_step(step)
+ results.append({'step': index, 'name': name, 'result': result})
+
+ self.job.status = 'succeeded'
+ self.job.completed_at = datetime.utcnow()
+ self.job.current_step_name = None
+ self.job.set_result({'steps': results})
+ db.session.commit()
+
+ self.log('info', 'Deployment completed')
+ return {'success': True, 'steps': results}
+
+ except Exception as exc:
+ self.job.status = 'failed'
+ self.job.completed_at = datetime.utcnow()
+ self.job.error_message = str(exc)
+ self.job.set_result({'steps': results})
+ db.session.commit()
+
+ self.log('error', str(exc), step_index=self.job.current_step)
+ return {'success': False, 'error': str(exc), 'steps': results}
+
+ def log(self, level: str, message: str, data: Any = None, step_index: int = None):
+ payload = None
+ if data is not None:
+ try:
+ payload = json.dumps(self._trim_data(data), default=str)
+ except TypeError:
+ payload = json.dumps(str(data))
+
+ entry = DeploymentJobLog(
+ job_id=self.job.id,
+ step_index=step_index,
+ level=level,
+ message=message,
+ data=payload,
+ )
+ db.session.add(entry)
+ db.session.commit()
+
+ def _execute_step(self, step: Dict[str, Any]) -> Any:
+ step_type = step.get('type')
+
+ if step_type == 'log':
+ self.log(step.get('level', 'info'), step.get('message', ''), step.get('data'))
+ return {'success': True}
+
+ if step_type == 'sleep':
+ seconds = min(float(step.get('seconds', 1)), 30)
+ time.sleep(seconds)
+ return {'success': True, 'seconds': seconds}
+
+ if step_type == 'file.write':
+ return self._file_write(step)
+
+ if step_type == 'docker.compose.up':
+ return self._compose_up(step)
+
+ if step_type == 'docker.compose.ps':
+ return self._compose_ps(step)
+
+ if step_type == 'docker.compose.logs':
+ return self._compose_logs(step)
+
+ raise DeploymentStepError(f"Unknown deployment step type: {step_type}")
+
+ def _file_write(self, step: Dict[str, Any]) -> Dict[str, Any]:
+ path = step.get('path')
+ content = step.get('content', '')
+ mode = int(step.get('mode', 0o644))
+
+ if not path:
+ raise DeploymentStepError('file.write step requires path')
+
+ if self.is_remote:
+ encoded = base64.b64encode(content.encode('utf-8')).decode('ascii')
+ data = self._send_agent_command(
+ 'file:write',
+ {
+ 'path': path,
+ 'content': encoded,
+ 'mode': mode,
+ 'create_dirs': step.get('create_dirs', True),
+ },
+ timeout=step.get('timeout', 30),
+ )
+ self.log('debug', f"Wrote remote file {path}", data)
+ return data
+
+ os.makedirs(os.path.dirname(path), exist_ok=True)
+ with open(path, 'w') as handle:
+ handle.write(content)
+ os.chmod(path, mode)
+ result = {'success': True, 'path': path, 'size': len(content)}
+ self.log('debug', f"Wrote local file {path}", result)
+ return result
+
+ def _compose_up(self, step: Dict[str, Any]) -> Dict[str, Any]:
+ detach = step.get('detach', True)
+ build = step.get('build', False)
+
+ if self.is_remote:
+ compose_file = step.get('compose_file') or step.get('project_path')
+ if not compose_file:
+ raise DeploymentStepError('docker.compose.up step requires compose_file for remote targets')
+ data = self._send_agent_command(
+ 'docker:compose:up',
+ {'project_path': compose_file, 'detach': detach, 'build': build},
+ timeout=step.get('timeout', 300),
+ )
+ self.log('debug', 'Remote compose up finished', data)
+ return data
+
+ project_dir = step.get('project_dir') or step.get('project_path')
+ if not project_dir:
+ raise DeploymentStepError('docker.compose.up step requires project_dir for local targets')
+ result = DockerService.compose_up(project_dir, detach=detach, build=build)
+ if not result.get('success'):
+ raise DeploymentStepError(result.get('error') or 'docker compose up failed')
+ self.log('debug', 'Local compose up finished', result)
+ return result
+
+ def _compose_ps(self, step: Dict[str, Any]) -> Dict[str, Any]:
+ if self.is_remote:
+ compose_file = step.get('compose_file') or step.get('project_path')
+ data = self._send_agent_command(
+ 'docker:compose:ps',
+ {'project_path': compose_file},
+ timeout=step.get('timeout', 30),
+ )
+ self.log('debug', 'Remote compose ps finished', data)
+ return {'containers': data}
+
+ project_dir = step.get('project_dir') or step.get('project_path')
+ containers = DockerService.compose_ps(project_dir)
+ result = {'containers': containers}
+ self.log('debug', 'Local compose ps finished', result)
+ return result
+
+ def _compose_logs(self, step: Dict[str, Any]) -> Dict[str, Any]:
+ service = step.get('service')
+ tail = int(step.get('tail', 100))
+
+ if self.is_remote:
+ compose_file = step.get('compose_file') or step.get('project_path')
+ data = self._send_agent_command(
+ 'docker:compose:logs',
+ {'project_path': compose_file, 'service': service or '', 'tail': tail},
+ timeout=step.get('timeout', 30),
+ )
+ self.log('debug', 'Remote compose logs fetched', data)
+ return data
+
+ project_dir = step.get('project_dir') or step.get('project_path')
+ result = DockerService.compose_logs(project_dir, service=service, tail=tail)
+ if not result.get('success'):
+ raise DeploymentStepError(result.get('error') or 'docker compose logs failed')
+ return result
+
+ def _send_agent_command(self, action: str, params: Dict[str, Any], timeout: float = 30.0) -> Any:
+ result = agent_registry.send_command(
+ server_id=self.job.target_server_id,
+ action=action,
+ params=params,
+ timeout=float(timeout),
+ user_id=self.job.requested_by,
+ )
+
+ if not result.get('success'):
+ raise DeploymentStepError(result.get('error') or f'Agent command failed: {action}')
+
+ data = result.get('data')
+ if isinstance(data, dict) and data.get('success') is False:
+ raise DeploymentStepError(data.get('error') or f'Agent command failed: {action}')
+
+ return data if data is not None else {'success': True}
+
+ def _trim_data(self, data: Any) -> Any:
+ if isinstance(data, str):
+ return data[:6000]
+ if isinstance(data, dict):
+ trimmed = {}
+ for key, value in data.items():
+ trimmed[key] = self._trim_data(value)
+ return trimmed
+ if isinstance(data, list):
+ return [self._trim_data(item) for item in data[:50]]
+ return data
diff --git a/backend/app/services/template_service.py b/backend/app/services/template_service.py
index 9a360633..34787e2f 100644
--- a/backend/app/services/template_service.py
+++ b/backend/app/services/template_service.py
@@ -470,6 +470,247 @@ class TemplateService:
return {'success': False, 'error': 'Template not found'}
+ @classmethod
+ def build_install_plan(cls, template_id: str, app_name: str,
+ user_variables: Dict = None, user_id: int = None,
+ server_id: str = None) -> Dict:
+ """Build a reusable deployment plan for installing a template.
+
+ The returned plan can be executed locally or by a connected agent.
+ """
+ result = cls.get_template(template_id)
+ if not result.get('success'):
+ return result
+
+ template = result['template']
+ variables_result = cls._prepare_install_variables(
+ template_id,
+ template,
+ app_name,
+ user_variables or {},
+ )
+ if not variables_result.get('success'):
+ return variables_result
+
+ variables = variables_result['variables']
+ app_path = os.path.join(cls.INSTALLED_DIR, app_name)
+ compose_file = os.path.join(app_path, 'docker-compose.yml')
+
+ compose_result = cls._render_compose_and_files(template, variables, app_path)
+ if not compose_result.get('success'):
+ return compose_result
+
+ install_info = {
+ 'template_id': template_id,
+ 'template_version': template.get('version'),
+ 'template_name': template.get('name'),
+ 'installed_at': datetime.now().isoformat(),
+ 'variables': variables,
+ 'user_id': user_id,
+ 'server_id': server_id,
+ }
+
+ env_content = ''.join(f"{key}={value}\n" for key, value in variables.items())
+
+ app_port = None
+ for port_var in ['PORT', 'HTTP_PORT', 'WEB_PORT']:
+ if port_var in variables:
+ try:
+ app_port = int(variables[port_var])
+ break
+ except (ValueError, TypeError):
+ pass
+
+ files = [
+ {
+ 'path': compose_file,
+ 'content': compose_result['compose_content'],
+ 'mode': 0o644,
+ },
+ {
+ 'path': os.path.join(app_path, '.serverkit-template.json'),
+ 'content': json.dumps(install_info, indent=2),
+ 'mode': 0o600,
+ },
+ {
+ 'path': os.path.join(app_path, '.env'),
+ 'content': env_content,
+ 'mode': 0o600,
+ },
+ ]
+ files.extend(compose_result.get('files', []))
+
+ steps = []
+ for file_def in files:
+ steps.append({
+ 'type': 'file.write',
+ 'name': f"Write {os.path.basename(file_def['path'])}",
+ 'path': file_def['path'],
+ 'content': file_def['content'],
+ 'mode': file_def.get('mode', 0o644),
+ 'create_dirs': True,
+ })
+
+ steps.append({
+ 'type': 'docker.compose.up',
+ 'name': 'Start Docker Compose stack',
+ 'project_dir': app_path,
+ 'compose_file': compose_file,
+ 'detach': True,
+ 'build': True,
+ 'timeout': 300,
+ })
+ steps.append({
+ 'type': 'sleep',
+ 'name': 'Wait for containers to initialize',
+ 'seconds': 3,
+ })
+ steps.append({
+ 'type': 'docker.compose.ps',
+ 'name': 'Capture container status',
+ 'project_dir': app_path,
+ 'compose_file': compose_file,
+ 'timeout': 30,
+ })
+
+ return {
+ 'success': True,
+ 'plan': {
+ 'kind': 'template_install',
+ 'template_id': template_id,
+ 'template_name': template.get('name'),
+ 'template_version': template.get('version'),
+ 'app_name': app_name,
+ 'app_path': app_path,
+ 'compose_file': compose_file,
+ 'variables': variables,
+ 'port': app_port,
+ 'server_id': server_id,
+ 'steps': steps,
+ },
+ 'template': template,
+ 'variables': variables,
+ 'app_path': app_path,
+ 'port': app_port,
+ }
+
+ @classmethod
+ def _prepare_install_variables(cls, template_id: str, template: Dict,
+ app_name: str, user_variables: Dict) -> Dict:
+ """Prepare template variables for installation."""
+ variables = {
+ 'APP_NAME': app_name,
+ }
+ template_vars = template.get('variables', {})
+
+ if isinstance(template_vars, list):
+ template_vars = {v['name']: v for v in template_vars if isinstance(v, dict) and 'name' in v}
+
+ for var_name, var_config in template_vars.items():
+ var_type = var_config.get('type', 'string')
+
+ if var_type == 'port':
+ variables[var_name] = cls.generate_value(var_config)
+ elif user_variables and var_name in user_variables and user_variables[var_name]:
+ variables[var_name] = user_variables[var_name]
+ elif var_config.get('required', False) and var_name not in user_variables:
+ return {'success': False, 'error': f"Required variable not provided: {var_name}"}
+ else:
+ variables[var_name] = cls.generate_value(var_config)
+
+ if template_id == 'wordpress-external-db':
+ db_check = cls.validate_mysql_connection(
+ host=variables.get('DB_HOST'),
+ port=variables.get('DB_PORT', '3306'),
+ user=variables.get('DB_USER'),
+ password=variables.get('DB_PASSWORD'),
+ database=variables.get('DB_NAME')
+ )
+ if not db_check.get('success'):
+ return {
+ 'success': False,
+ 'error': f"Database connection failed: {db_check.get('error')}"
+ }
+
+ return {'success': True, 'variables': variables}
+
+ @classmethod
+ def _render_compose_and_files(cls, template: Dict, variables: Dict, app_path: str) -> Dict:
+ """Render compose YAML and any template-defined files in memory."""
+ try:
+ compose = cls.substitute_in_dict(template.get('compose', {}), variables)
+ if 'version' in compose:
+ del compose['version']
+
+ rendered_files = []
+ bind_mounts = []
+
+ for file_def in template.get('files', []) or []:
+ container_path = file_def.get('path')
+ content = file_def.get('content', '')
+ if not container_path:
+ continue
+
+ content = cls.substitute_variables(content, variables)
+ filename = os.path.basename(container_path)
+ rendered_files.append({
+ 'path': os.path.join(app_path, filename),
+ 'content': content,
+ 'mode': int(file_def.get('mode', 0o644)),
+ })
+ bind_mounts.append({
+ 'local': f'./{filename}',
+ 'container': container_path,
+ 'container_dir': os.path.dirname(container_path),
+ })
+
+ if bind_mounts:
+ cls._apply_bind_mounts_to_compose(compose, bind_mounts)
+
+ return {
+ 'success': True,
+ 'compose_content': yaml.dump(compose, default_flow_style=False, sort_keys=False),
+ 'files': rendered_files,
+ }
+ except Exception as e:
+ return {'success': False, 'error': f'Failed to render template: {str(e)}'}
+
+ @classmethod
+ def _apply_bind_mounts_to_compose(cls, compose: Dict, bind_mounts: List[Dict]) -> None:
+ """Apply file bind mounts to a compose dictionary."""
+ volumes_to_remove = set()
+
+ for service in compose.get('services', {}).values():
+ volumes = service.get('volumes', [])
+ new_volumes = []
+
+ for vol in volumes:
+ if isinstance(vol, str):
+ parts = vol.split(':')
+ if len(parts) >= 2:
+ mount_target = parts[1].rstrip('/')
+ should_replace = any(
+ mount_target == mount['container_dir'].rstrip('/')
+ for mount in bind_mounts
+ )
+ if should_replace:
+ volumes_to_remove.add(parts[0])
+ continue
+ new_volumes.append(vol)
+
+ for mount in bind_mounts:
+ bind_mount = f"{mount['local']}:{mount['container']}"
+ if bind_mount not in new_volumes:
+ new_volumes.append(bind_mount)
+
+ service['volumes'] = new_volumes
+
+ if 'volumes' in compose:
+ for volume_name in volumes_to_remove:
+ compose['volumes'].pop(volume_name, None)
+ if not compose['volumes']:
+ del compose['volumes']
+
@classmethod
def install_template(cls, template_id: str, app_name: str,
user_variables: Dict = None, user_id: int = None) -> Dict:
diff --git a/backend/cli.py b/backend/cli.py
index 52fa31db..6c667541 100644
--- a/backend/cli.py
+++ b/backend/cli.py
@@ -647,5 +647,105 @@ def list_apps(show_all):
click.echo('')
[email protected]('list-servers')
+def list_servers():
+ """List deployment targets."""
+ app = create_app()
+ with app.app_context():
+ from app.services.remote_docker_service import RemoteDockerService
+
+ servers = RemoteDockerService.get_available_servers()
+ click.echo(f"\n{'ID':<38} {'Name':<28} {'Status':<12} {'Target'}")
+ click.echo('-' * 90)
+ for server in servers:
+ target = 'local' if server.get('is_local') else server.get('group_name') or 'remote'
+ click.echo(
+ f"{server.get('id'):<38} "
+ f"{server.get('name'):<28} "
+ f"{server.get('status', '-'):<12} "
+ f"{target}"
+ )
+ click.echo('')
+
+
[email protected]('deploy-template')
[email protected]('template_id')
[email protected]('--name', 'app_name', required=True, help='Application name')
[email protected]('--target', 'server_id', default='local', help='Target server ID or "local"')
[email protected]('--var', 'variables', multiple=True, help='Template variable in KEY=VALUE form')
[email protected]('--wait', is_flag=True, help='Wait for deployment to finish')
+def deploy_template(template_id, app_name, server_id, variables, wait):
+ """Deploy a template to local or remote ServerKit target."""
+ app = create_app()
+ with app.app_context():
+ from app.services.deployment_job_service import DeploymentJobService
+
+ parsed_vars = {}
+ for item in variables:
+ if '=' not in item:
+ click.echo(click.style(f'Invalid --var value: {item}. Use KEY=VALUE.', fg='red'))
+ sys.exit(1)
+ key, value = item.split('=', 1)
+ parsed_vars[key] = value
+
+ result = DeploymentJobService.install_template(
+ template_id=template_id,
+ app_name=app_name,
+ user_variables=parsed_vars,
+ server_id=server_id,
+ wait=wait,
+ )
+
+ if not result.get('success'):
+ click.echo(click.style(result.get('error', 'Deployment failed'), fg='red'))
+ sys.exit(1)
+
+ job = result.get('job', {})
+ click.echo(click.style(f'Deployment job created: {job.get("id")}', fg='green'))
+ click.echo(f'Status: {job.get("status")}')
+ click.echo(f'Target: {job.get("target_server_name")}')
+
+ if wait:
+ if job.get('status') == 'succeeded':
+ click.echo(click.style(f'App created: {job.get("result", {}).get("app_name")}', fg='green'))
+ else:
+ click.echo(click.style(job.get('error_message') or 'Deployment did not complete successfully', fg='red'))
+ sys.exit(1)
+ else:
+ click.echo(f'Check status: serverkit deployment-status {job.get("id")}')
+
+
[email protected]('deployment-status')
[email protected]('--logs', is_flag=True, help='Show job logs')
+def deployment_status(job_id, logs):
+ """Show deployment job status."""
+ app = create_app()
+ with app.app_context():
+ from app.services.deployment_job_service import DeploymentJobService
+
+ job = DeploymentJobService.get_job(job_id, include_logs=logs)
+ if not job:
+ click.echo(click.style('Deployment job not found', fg='red'))
+ sys.exit(1)
+
+ click.echo(f"\nJob: {job['id']}")
+ click.echo(f"Kind: {job['kind']}")
+ click.echo(f"Status: {job['status']} ({job['progress_percent']}%)")
+ click.echo(f"Target: {job['target_server_name']}")
+ if job.get('app_name'):
+ click.echo(f"App: {job['app_name']}")
+ if job.get('error_message'):
+ click.echo(click.style(f"Error: {job['error_message']}", fg='red'))
+
+ if logs:
+ click.echo('\nLogs')
+ click.echo('-' * 80)
+ for entry in job.get('logs', []):
+ prefix = f"[{entry['step_index']}] " if entry.get('step_index') else ''
+ click.echo(f"{entry['created_at']} {entry['level'].upper():<5} {prefix}{entry['message']}")
+ click.echo('')
+
+
if __name__ == '__main__':
cli()
diff --git a/backend/migrations/versions/004_deployment_jobs.py b/backend/migrations/versions/004_deployment_jobs.py
new file mode 100644
index 00000000..d8c03fd5
--- /dev/null
+++ b/backend/migrations/versions/004_deployment_jobs.py
@@ -0,0 +1,101 @@
+"""Add deployment jobs and app server targets.
+
+Revision ID: 004_deployment_jobs
+Revises: 003_workflows_automation
+Create Date: 2026-04-29
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+revision = '004_deployment_jobs'
+down_revision = '003_workflows_automation'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ existing_tables = inspector.get_table_names()
+
+ if 'applications' in existing_tables:
+ existing_cols = {c['name'] for c in inspector.get_columns('applications')}
+ if 'server_id' not in existing_cols:
+ with op.batch_alter_table('applications') as batch_op:
+ batch_op.add_column(sa.Column('server_id', sa.String(36), nullable=True))
+ batch_op.create_index('ix_applications_server_id', ['server_id'])
+ batch_op.create_foreign_key(
+ 'fk_applications_server_id_servers',
+ 'servers',
+ ['server_id'],
+ ['id'],
+ )
+
+ if 'deployment_jobs' not in existing_tables:
+ op.create_table(
+ 'deployment_jobs',
+ sa.Column('id', sa.String(36), primary_key=True),
+ sa.Column('kind', sa.String(50), nullable=False),
+ sa.Column('status', sa.String(20), nullable=False, server_default='pending'),
+ sa.Column('target_server_id', sa.String(36), sa.ForeignKey('servers.id'), nullable=True),
+ sa.Column('app_id', sa.Integer(), sa.ForeignKey('applications.id'), nullable=True),
+ sa.Column('requested_by', sa.Integer(), sa.ForeignKey('users.id'), nullable=True),
+ sa.Column('trigger', sa.String(30), nullable=True, server_default='manual'),
+ sa.Column('total_steps', sa.Integer(), nullable=True, server_default='0'),
+ sa.Column('current_step', sa.Integer(), nullable=True, server_default='0'),
+ sa.Column('current_step_name', sa.String(200), nullable=True),
+ sa.Column('plan', sa.Text(), nullable=True, server_default='{}'),
+ sa.Column('result', sa.Text(), nullable=True, server_default='{}'),
+ sa.Column('error_message', sa.Text(), nullable=True),
+ sa.Column('created_at', sa.DateTime(), server_default=sa.func.now()),
+ sa.Column('started_at', sa.DateTime(), nullable=True),
+ sa.Column('completed_at', sa.DateTime(), nullable=True),
+ sa.Column('updated_at', sa.DateTime(), server_default=sa.func.now()),
+ )
+ op.create_index('ix_deployment_jobs_kind', 'deployment_jobs', ['kind'])
+ op.create_index('ix_deployment_jobs_status', 'deployment_jobs', ['status'])
+ op.create_index('ix_deployment_jobs_target_server_id', 'deployment_jobs', ['target_server_id'])
+ op.create_index('ix_deployment_jobs_app_id', 'deployment_jobs', ['app_id'])
+ op.create_index('ix_deployment_jobs_created_at', 'deployment_jobs', ['created_at'])
+
+ if 'deployment_job_logs' not in existing_tables:
+ op.create_table(
+ 'deployment_job_logs',
+ sa.Column('id', sa.BigInteger(), primary_key=True, autoincrement=True),
+ sa.Column('job_id', sa.String(36), sa.ForeignKey('deployment_jobs.id'), nullable=False),
+ sa.Column('step_index', sa.Integer(), nullable=True),
+ sa.Column('level', sa.String(10), nullable=True, server_default='info'),
+ sa.Column('message', sa.Text(), nullable=False),
+ sa.Column('data', sa.Text(), nullable=True),
+ sa.Column('created_at', sa.DateTime(), server_default=sa.func.now()),
+ )
+ op.create_index('ix_deployment_job_logs_job_id', 'deployment_job_logs', ['job_id'])
+ op.create_index('ix_deployment_job_logs_created_at', 'deployment_job_logs', ['created_at'])
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ existing_tables = inspector.get_table_names()
+
+ if 'deployment_job_logs' in existing_tables:
+ op.drop_index('ix_deployment_job_logs_created_at', table_name='deployment_job_logs')
+ op.drop_index('ix_deployment_job_logs_job_id', table_name='deployment_job_logs')
+ op.drop_table('deployment_job_logs')
+
+ if 'deployment_jobs' in existing_tables:
+ op.drop_index('ix_deployment_jobs_created_at', table_name='deployment_jobs')
+ op.drop_index('ix_deployment_jobs_app_id', table_name='deployment_jobs')
+ op.drop_index('ix_deployment_jobs_target_server_id', table_name='deployment_jobs')
+ op.drop_index('ix_deployment_jobs_status', table_name='deployment_jobs')
+ op.drop_index('ix_deployment_jobs_kind', table_name='deployment_jobs')
+ op.drop_table('deployment_jobs')
+
+ if 'applications' in existing_tables:
+ existing_cols = {c['name'] for c in inspector.get_columns('applications')}
+ if 'server_id' in existing_cols:
+ with op.batch_alter_table('applications') as batch_op:
+ batch_op.drop_constraint('fk_applications_server_id_servers', type_='foreignkey')
+ batch_op.drop_index('ix_applications_server_id')
+ batch_op.drop_column('server_id')
diff --git a/frontend/src/pages/Applications.jsx b/frontend/src/pages/Applications.jsx
index 7a3f3a8d..155562b5 100644
--- a/frontend/src/pages/Applications.jsx
+++ b/frontend/src/pages/Applications.jsx
@@ -431,15 +431,9 @@ const AppLogsModal = ({ app, onClose }) => {
try {
// For Docker apps, try to get container logs
if (app.app_type === 'docker') {
- const containersData = await api.getContainers(true).catch(() => ({ containers: [] }));
- const appContainer = containersData.containers?.find(c =>
- c.name?.includes(app.name) || c.name?.includes(app.id)
- );
- if (appContainer) {
- const data = await api.getContainerLogs(appContainer.id, 200);
- setLogs(data.logs || 'No logs available');
- return;
- }
+ const data = await api.getDockerAppLogs(app.id, 200);
+ setLogs(data.logs || data.content || 'No logs available');
+ return;
}
// For other apps, use app logs endpoint
const data = await api.getAppLogs(app.name, logType, 200);
diff --git a/frontend/src/pages/Servers.jsx b/frontend/src/pages/Servers.jsx
index 2ba5b5e6..2602a559 100644
--- a/frontend/src/pages/Servers.jsx
+++ b/frontend/src/pages/Servers.jsx
@@ -312,7 +312,7 @@ const AddServerModal = ({ groups, onClose, onCreated }) => {
group_id: '',
hostname: '',
ip_address: '',
- permission_profile: 'docker_manager',
+ permission_profile: 'deployment_runner',
permissions: []
});
const [registrationData, setRegistrationData] = useState(null);
@@ -424,6 +424,7 @@ Install-ServerKitAgent -Server "${window.location.origin}" -Token "${registratio
<div className="form-group">
<label>Access Profile</label>
<select name="permission_profile" value={formData.permission_profile} onChange={handleChange}>
+ <option value="deployment_runner">Deployment Runner</option>
<option value="docker_manager">Docker Manager</option>
<option value="docker_readonly">Docker Read-Only</option>
<option value="full_access">Full Access</option>
diff --git a/frontend/src/pages/Templates.jsx b/frontend/src/pages/Templates.jsx
index ee2b3409..7757e6a1 100644
--- a/frontend/src/pages/Templates.jsx
+++ b/frontend/src/pages/Templates.jsx
@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
import { useNavigate, useSearchParams } from 'react-router-dom';
import {
Search, X, Star, ExternalLink, BookOpen, Container, Globe, BarChart3,
@@ -605,8 +605,13 @@ const InstallModal = ({ template, onClose, onSuccess }) => {
const toast = useToast();
const [appName, setAppName] = useState(template.id.toLowerCase().replace(/[^a-z0-9-]/g, '-'));
const [variables, setVariables] = useState({});
+ const [servers, setServers] = useState([{ id: 'local', name: 'Local server', is_local: true }]);
+ const [selectedServerId, setSelectedServerId] = useState('local');
const [installing, setInstalling] = useState(false);
const [errors, setErrors] = useState([]);
+ const [job, setJob] = useState(null);
+ const [jobLogs, setJobLogs] = useState([]);
+ const pollRef = useRef(null);
useEffect(() => {
// Initialize variables with defaults
@@ -619,10 +624,65 @@ const InstallModal = ({ template, onClose, onSuccess }) => {
setVariables(defaults);
}, [template]);
+ useEffect(() => {
+ loadServers();
+ return () => {
+ if (pollRef.current) {
+ clearInterval(pollRef.current);
+ }
+ };
+ }, []);
+
+ async function loadServers() {
+ try {
+ const data = await api.getAvailableServers();
+ const list = Array.isArray(data) ? data : [];
+ if (list.length > 0) {
+ setServers(list);
+ setSelectedServerId(list[0].id);
+ }
+ } catch {
+ setServers([{ id: 'local', name: 'Local server', is_local: true }]);
+ setSelectedServerId('local');
+ }
+ }
+
+ function startPolling(jobId) {
+ if (pollRef.current) {
+ clearInterval(pollRef.current);
+ }
+
+ pollRef.current = setInterval(async () => {
+ try {
+ const data = await api.getDeploymentJob(jobId, true);
+ const latestJob = data.job;
+ setJob(latestJob);
+ setJobLogs(latestJob.logs || []);
+
+ if (latestJob.status === 'succeeded' && latestJob.result?.app_id) {
+ clearInterval(pollRef.current);
+ pollRef.current = null;
+ setInstalling(false);
+ onSuccess(latestJob.result?.app_id);
+ } else if (latestJob.status === 'failed') {
+ clearInterval(pollRef.current);
+ pollRef.current = null;
+ setInstalling(false);
+ setErrors([latestJob.error_message || 'Deployment failed']);
+ toast.error(latestJob.error_message || 'Deployment failed');
+ }
+ } catch (err) {
+ console.error('Failed to poll deployment job:', err);
+ }
+ }, 1500);
+ }
+
async function handleInstall(e) {
e.preventDefault();
setInstalling(true);
setErrors([]);
+ setJob(null);
+ setJobLogs([]);
try {
// Validate first
@@ -634,15 +694,21 @@ const InstallModal = ({ template, onClose, onSuccess }) => {
}
// Install
- const result = await api.installTemplate(template.id, appName, variables);
- if (result.success) {
+ const result = await api.installTemplate(template.id, appName, variables, {
+ serverId: selectedServerId
+ });
+ if (result.success && result.job_id) {
+ setJob(result.job);
+ setJobLogs(result.job?.logs || []);
+ startPolling(result.job_id);
+ } else if (result.success) {
onSuccess(result.app_id);
} else {
setErrors([result.error || 'Installation failed']);
+ setInstalling(false);
}
} catch (err) {
setErrors([err.message || 'Installation failed']);
- } finally {
setInstalling(false);
}
}
@@ -677,6 +743,21 @@ const InstallModal = ({ template, onClose, onSuccess }) => {
<span className="form-help">Lowercase letters, numbers, and hyphens only (min 2 chars)</span>
</div>
+ <div className="form-group">
+ <label>Target Server</label>
+ <select
+ value={selectedServerId}
+ onChange={(e) => setSelectedServerId(e.target.value)}
+ disabled={installing}
+ >
+ {servers.map(server => (
+ <option key={server.id} value={server.id}>
+ {server.name}{server.is_local ? ' (local)' : ''}
+ </option>
+ ))}
+ </select>
+ </div>
+
{(template.variables || []).filter(v => !v.hidden).length > 0 && (
<>
<h4>Configuration</h4>
@@ -721,6 +802,27 @@ const InstallModal = ({ template, onClose, onSuccess }) => {
))}
</>
)}
+
+ {job && (
+ <div className="detail-section">
+ <h4>Deployment Status</h4>
+ <div className="deployment-progress">
+ <div className="deployment-progress-track">
+ <div
+ className="deployment-progress-fill"
+ style={{ width: `${job.progress_percent || 0}%` }}
+ />
+ </div>
+ <span>{job.status} {job.progress_percent || 0}%</span>
+ </div>
+ <pre className="log-viewer">
+ {(jobLogs || []).map(log => {
+ const prefix = log.step_index ? `[${log.step_index}] ` : '';
+ return `${prefix}${log.message}`;
+ }).join('\n') || 'Waiting for deployment logs...'}
+ </pre>
+ </div>
+ )}
</div>
<div className="modal-footer">
<button type="button" className="btn btn-secondary" onClick={onClose} disabled={installing}>
diff --git a/frontend/src/services/api/apps.js b/frontend/src/services/api/apps.js
index 2bf40f0f..86165554 100644
--- a/frontend/src/services/api/apps.js
+++ b/frontend/src/services/api/apps.js
@@ -188,10 +188,15 @@ export async function getTemplate(templateId) {
return this.request(`/templates/${templateId}`);
}
-export async function installTemplate(templateId, appName, variables = {}) {
+export async function installTemplate(templateId, appName, variables = {}, options = {}) {
return this.request(`/templates/${templateId}/install`, {
method: 'POST',
- body: { app_name: appName, variables }
+ body: {
+ app_name: appName,
+ variables,
+ server_id: options.serverId || 'local',
+ wait: options.wait || false,
+ }
});
}
diff --git a/frontend/src/services/api/deploymentJobs.js b/frontend/src/services/api/deploymentJobs.js
new file mode 100644
index 00000000..97e6fd87
--- /dev/null
+++ b/frontend/src/services/api/deploymentJobs.js
@@ -0,0 +1,19 @@
+// Deployment jobs and logs
+
+export async function getDeploymentJobs(params = {}) {
+ const query = new URLSearchParams();
+ if (params.status) query.append('status', params.status);
+ if (params.serverId) query.append('server_id', params.serverId);
+ if (params.limit) query.append('limit', params.limit);
+ const suffix = query.toString() ? `?${query}` : '';
+ return this.request(`/deployment-jobs${suffix}`);
+}
+
+export async function getDeploymentJob(jobId, includeLogs = true) {
+ return this.request(`/deployment-jobs/${jobId}?logs=${includeLogs}`);
+}
+
+export async function getDeploymentJobLogs(jobId, afterId = null) {
+ const suffix = afterId ? `?after_id=${afterId}` : '';
+ return this.request(`/deployment-jobs/${jobId}/logs${suffix}`);
+}
diff --git a/frontend/src/services/api/index.js b/frontend/src/services/api/index.js
index eecbb3f7..99785eb2 100644
--- a/frontend/src/services/api/index.js
+++ b/frontend/src/services/api/index.js
@@ -10,6 +10,7 @@ import * as securityMethods from './security.js';
import * as fileMethods from './files.js';
import * as dnsMethods from './dns.js';
import * as pluginMethods from './plugins.js';
+import * as deploymentJobMethods from './deploymentJobs.js';
class ApiService extends ApiClient {
constructor() {
@@ -27,6 +28,7 @@ class ApiService extends ApiClient {
fileMethods,
dnsMethods,
pluginMethods,
+ deploymentJobMethods,
];
for (const mod of modules) {
for (const [key, fn] of Object.entries(mod)) {
diff --git a/frontend/src/styles/pages/_templates.scss b/frontend/src/styles/pages/_templates.scss
index a5b3dadf..6a72c21e 100644
--- a/frontend/src/styles/pages/_templates.scss
+++ b/frontend/src/styles/pages/_templates.scss
@@ -631,6 +631,35 @@
}
}
+.deployment-progress {
+ display: grid;
+ grid-template-columns: 1fr auto;
+ align-items: center;
+ gap: $space-3;
+ margin-bottom: $space-3;
+
+ span {
+ font-size: $font-size-sm;
+ color: $text-secondary;
+ text-transform: capitalize;
+ white-space: nowrap;
+ }
+}
+
+.deployment-progress-track {
+ height: 8px;
+ background: $bg-elevated;
+ border: 1px solid $border-subtle;
+ border-radius: $radius-sm;
+ overflow: hidden;
+}
+
+.deployment-progress-fill {
+ height: 100%;
+ background: $primary;
+ transition: width 180ms ease;
+}
+
// Responsive
@media (max-width: $breakpoint-md) {
.templates-grid {
diff --git a/serverkit b/serverkit
index a3059378..8fa0864e 100644
--- a/serverkit
+++ b/serverkit
@@ -179,6 +179,9 @@ cmd_help() {
echo ""
echo "App Management:"
echo " create-app Show how to create apps (via web UI)"
+ echo " deploy-template Deploy a template to local or remote server"
+ echo " list-servers List deployment target servers"
+ echo " deployment-status Show deployment job status and logs"
echo " list-apps [--all] List deployed apps (--all shows Docker containers)"
echo " start-app Start an app"
echo " stop-app Stop an app"
@@ -766,6 +769,23 @@ cmd_create_app() {
echo ""
}
+cmd_deploy_template() {
+ check_installed
+ shift
+ run_cli deploy-template "$@"
+}
+
+cmd_list_servers() {
+ check_installed
+ run_cli list-servers
+}
+
+cmd_deployment_status() {
+ check_installed
+ shift
+ run_cli deployment-status "$@"
+}
+
cmd_list_apps() {
check_installed
# Pass --all flag if provided
@@ -1349,6 +1369,15 @@ case "${1:-help}" in
create-app)
cmd_create_app "$2" "$3" "$4"
;;
+ deploy-template)
+ cmd_deploy_template "$@"
+ ;;
+ list-servers)
+ cmd_list_servers
+ ;;
+ deployment-status)
+ cmd_deployment_status "$@"
+ ;;
list-apps)
cmd_list_apps "$2"
;;