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
import { useCallback, useState, useEffect, useId } from 'react';
import { useNavigate } from 'react-router-dom';
import api from '../../services/api';
import EmptyState from '../EmptyState';
import { useToast } from '../../contexts/useToast.js';
import { useConfirm } from '../../hooks/useConfirm';
import { InfoList, InfoItem } from '../InfoList';
import BuildpackPreview from '../buildpack/BuildpackPreview';
import { Button } from '@/components/ui/button';
import { Input } from '@/components/ui/input';
import { Select, SelectTrigger, SelectContent, SelectItem, SelectValue } from '@/components/ui/select';
import { Pill, statusKind } from '@/components/ds';
import Modal from '@/components/Modal';
import { useTranslation } from 'react-i18next';
import { Card as SharedCard } from '@/components/ui/card';
import { CardHeader as SharedCardHeader, CardFooter as SharedCardFooter } from '@/components/ui/card';
import { formatDateTime } from '@/utils/intl';
import { formatDuration } from '@/utils/serviceTypes';
const BuildTab = ({ appId, app }) => {
const { t } = useTranslation();
const fieldId = useId();
const toast = useToast();
const { confirm: confirmBuild } = useConfirm();
const [buildConfig, setBuildConfig] = useState(null);
const [detection, setDetection] = useState(null);
const [deployments, setDeployments] = useState([]);
const [loading, setLoading] = useState(true);
const [building, setBuilding] = useState(false);
const [deploying, setDeploying] = useState(false);
const navigate = useNavigate();
const [showConfigModal, setShowConfigModal] = useState(false);
const [error, setError] = useState(null);
const [bpDockerfile, setBpDockerfile] = useState(null);
// When the app was created from a detected build pack, fetch a read-only
// preview of the generated Dockerfile for transparency.
useEffect(() => {
let active = true;
if (app?.buildpack_plan) {
api.generateBuildpack(app.buildpack_plan, app.buildpack_overrides || {}, app.name)
.then((res) => { if (active) setBpDockerfile(res?.dockerfile || null); })
.catch(() => {});
}
return () => { active = false; };
}, [app?.buildpack_plan, app?.buildpack_overrides, app?.name]);
const [configForm, setConfigForm] = useState({
buildMethod: 'auto',
dockerfilePath: 'Dockerfile',
customBuildCmd: '',
customStartCmd: '',
cacheEnabled: true,
timeout: 600,
keepDeployments: 5
});
const loadData = useCallback(async () => {
try {
setLoading(true);
const [configRes, detectRes, deploymentsRes] = await Promise.all([
api.getBuildConfig(appId),
api.detectBuildMethod(appId),
api.getDeployments(appId, 10)
]);
setDetection(detectRes);
if (configRes.configured) {
setBuildConfig(configRes.config);
setConfigForm({
buildMethod: configRes.config.build_method || 'auto',
dockerfilePath: configRes.config.dockerfile_path || 'Dockerfile',
customBuildCmd: configRes.config.custom_build_cmd || '',
customStartCmd: configRes.config.custom_start_cmd || '',
cacheEnabled: configRes.config.cache_enabled !== false,
timeout: configRes.config.timeout || 600,
keepDeployments: configRes.config.keep_deployments || 5
});
}
setDeployments(deploymentsRes.deployments || []);
} catch (err) {
setError(err.message);
} finally {
setLoading(false);
}
}, [appId]);
useEffect(() => {
loadData();
}, [loadData]);
async function handleConfigureBuild(e) {
e.preventDefault();
try {
await api.configureBuild(appId, {
build_method: configForm.buildMethod,
dockerfile_path: configForm.dockerfilePath,
custom_build_cmd: configForm.customBuildCmd || null,
custom_start_cmd: configForm.customStartCmd || null,
cache_enabled: configForm.cacheEnabled,
timeout: configForm.timeout,
keep_deployments: configForm.keepDeployments
});
setShowConfigModal(false);
toast.success(t('app.buildTab.buildConfigurationSaved', 'Build settings saved'));
loadData();
} catch (err) {
setError(err.message);
}
}
async function handleBuild(noCache = false) {
setBuilding(true);
setError(null);
try {
const result = await api.triggerBuild(appId, noCache);
if (result.success) {
toast.success(t('app.buildTab.buildCompletedSuccessfully', 'Build completed'));
} else {
setError(result.error || 'Build failed');
}
loadData();
} catch (err) {
setError(err.message);
} finally {
setBuilding(false);
}
}
async function handleDeploy(noCache = false) {
setDeploying(true);
setError(null);
try {
const result = await api.deployApp(appId, { no_cache: noCache });
if (result?.deploy_job_id) {
// Async deploy → watch it live on the Deploy Console.
navigate(`/deployments/${result.deploy_job_id}`);
return;
}
if (result.success) {
toast.success(t('app.buildTab.deploymentStarted', 'Deployment started'));
} else {
setError(result.error || 'Deployment failed');
}
loadData();
} catch (err) {
setError(err.message);
} finally {
setDeploying(false);
}
}
async function handleRollback(version = null) {
const rollbackMsg = version
? `Rollback to version ${version}? This will replace the current deployment.`
: 'Rollback to previous deployment?';
const confirmed = await confirmBuild({ titleKey: 'app.buildTab.rollback', title: 'Rollback', message: rollbackMsg, variant: 'warning' });
if (!confirmed) return;
setDeploying(true);
setError(null);
try {
const result = await api.rollback(appId, version);
if (result.success) {
toast.success(t('app.buildTab.rollbackSuccessful', 'Rollback successful'));
} else {
setError(result.error || 'Rollback failed');
}
loadData();
} catch (err) {
setError(err.message);
} finally {
setDeploying(false);
}
}
if (loading) {
return <EmptyState loading loadingVariant="form" title={t('app.buildTab.loadingBuildConfiguration', 'Loading build settings…')} />;
}
return (
<div className="build-tab">
{error && (
<div className="alert alert-danger">
{error}
<Button variant="unstyled" type="button" onClick={() => setError(null)} className="alert-close">×</Button>
</div>
)}
{detection && (
<SharedCard variant="legacy" className="card">
<h3>{t('app.buildTab.autoDetectionResults', 'Auto-detection results')}</h3>
<div className="detection-results">
<div className="detection-item">
<span className="detection-label">{t('app.buildTab.detectedMethod', 'Detected method:')}</span>
<span className="detection-value">{detection.detected_method || t('app.buildTab.none', 'None')}</span>
</div>
{detection.dockerfile_exists && (
<div className="detection-item">
<span className="detection-label">{t('app.buildTab.dockerfile', 'Dockerfile:')}</span>
<span className="detection-value">{t('app.buildTab.found', 'Found')}</span>
</div>
)}
{detection.docker_compose_exists && (
<div className="detection-item">
<span className="detection-label">{t('app.buildTab.dockerCompose', 'Docker Compose:')}</span>
<span className="detection-value">{t('app.buildTab.found', 'Found')}</span>
</div>
)}
</div>
</SharedCard>
)}
{app?.buildpack_plan && (
<SharedCard variant="legacy" className="card">
<h3>{t('app.buildTab.buildPack', 'Build pack')}</h3>
<BuildpackPreview
plan={app.buildpack_plan}
dockerfile={bpDockerfile}
overrides={app.buildpack_overrides || {}}
/>
</SharedCard>
)}
<SharedCard variant="legacy" className="card">
<SharedCardHeader variant="legacy-row" className="card-header-row">
<h3>{t('app.buildTab.buildConfiguration', 'Build settings')}</h3>
<Button variant="outline" size="sm" onClick={() => setShowConfigModal(true)}>
{t('app.buildTab.configure', 'Configure')}
</Button>
</SharedCardHeader>
{buildConfig ? (
<InfoList>
<InfoItem label={t('app.buildTab.method', 'Method')} value={buildConfig.build_method} />
<InfoItem label={t('app.buildTab.timeout', 'Timeout')} value={`${buildConfig.timeout}s`} />
</InfoList>
) : (
<p className="hint">{t('app.buildTab.noBuildConfigurationClickConfigureTo', 'No build settings. Click Configure to set up.')}</p>
)}
<SharedCardFooter variant="legacy" className="card-actions">
<Button
onClick={() => handleDeploy(false)}
disabled={deploying || building}
>
{deploying ? t('app.buildTab.deploying', 'Deploying…') : t('app.buildTab.buildAndDeploy', 'Build & deploy')}
</Button>
<Button
variant="outline"
onClick={() => handleBuild(false)}
disabled={building || deploying}
>
{building ? t('app.buildTab.building', 'Building…') : t('app.buildTab.buildOnly', 'Build only')}
</Button>
</SharedCardFooter>
</SharedCard>
{deployments.length > 0 && (
<SharedCard variant="legacy" className="card">
<h3>{t('app.buildTab.deploymentHistory', 'Deployment history')}</h3>
<div className="deployments-list">
{deployments.map(dep => (
<div key={dep.version} className={`deployment-item ${dep.status === 'live' ? 'current' : ''}`}>
<div className="deployment-info">
<span className="deployment-version">v{dep.version}</span>
<Pill kind={statusKind(dep.status)}>{dep.status}</Pill>
</div>
<div className="deployment-meta">
<span>{formatDateTime(dep.created_at)}</span>
<span>{formatDuration(dep.build_duration)}</span>
</div>
{dep.status !== 'live' && (
<Button
variant="outline"
size="sm"
onClick={() => handleRollback(dep.version)}
disabled={deploying}
>
{t('app.buildTab.rollback', 'Rollback')}
</Button>
)}
</div>
))}
</div>
</SharedCard>
)}
<Modal open={showConfigModal} onClose={() => setShowConfigModal(false)} title={t('app.buildTab.buildConfiguration', 'Build settings')}>
<form onSubmit={handleConfigureBuild}>
<div className="form-group">
<label htmlFor="build-config-method">{t('app.buildTab.buildMethod', 'Build method')}</label>
<Select
value={configForm.buildMethod}
onValueChange={value => setConfigForm({...configForm, buildMethod: value})}
>
<SelectTrigger id="build-config-method"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="auto">{t('app.buildTab.autoDetect', 'Auto-detect')}</SelectItem>
<SelectItem value="dockerfile">{t('app.buildTab.dockerfile2', 'Dockerfile')}</SelectItem>
<SelectItem value="docker-compose">{t('app.buildTab.dockerCompose2', 'Docker Compose')}</SelectItem>
<SelectItem value="custom">{t('app.buildTab.custom', 'Custom')}</SelectItem>
</SelectContent>
</Select>
</div>
{configForm.buildMethod === 'dockerfile' && (
<div className="form-group">
<label htmlFor={`${fieldId}-dockerfile`}>{t('app.buildTab.dockerfilePath', 'Dockerfile path')}</label>
<Input
id={`${fieldId}-dockerfile`}
type="text"
value={configForm.dockerfilePath}
onChange={e => setConfigForm({...configForm, dockerfilePath: e.target.value})}
/>
</div>
)}
{configForm.buildMethod === 'custom' && (
<>
<div className="form-group">
<label htmlFor={`${fieldId}-build-cmd`}>{t('app.buildTab.buildCommand', 'Build command')}</label>
<Input
id={`${fieldId}-build-cmd`}
type="text"
value={configForm.customBuildCmd}
onChange={e => setConfigForm({...configForm, customBuildCmd: e.target.value})}
placeholder={t('app.buildTab.npmRunBuild', 'npm run build')}
/>
</div>
<div className="form-group">
<label htmlFor={`${fieldId}-start-cmd`}>{t('app.buildTab.startCommand', 'Start command')}</label>
<Input
id={`${fieldId}-start-cmd`}
type="text"
value={configForm.customStartCmd}
onChange={e => setConfigForm({...configForm, customStartCmd: e.target.value})}
placeholder={t('app.buildTab.npmStart', 'npm start')}
/>
</div>
</>
)}
<div className="form-group">
<label htmlFor={`${fieldId}-timeout`}>{t('app.buildTab.timeoutSeconds', 'Timeout (seconds)')}</label>
<Input
id={`${fieldId}-timeout`}
type="number"
value={configForm.timeout}
onChange={e => setConfigForm({...configForm, timeout: parseInt(e.target.value)})}
/>
</div>
<div className="modal-actions">
<Button type="button" variant="outline" onClick={() => setShowConfigModal(false)}>
{t('common.actions.cancel', 'Cancel')}
</Button>
<Button type="submit">
{t('app.buildTab.saveConfiguration', 'Save settings')}
</Button>
</div>
</form>
</Modal>
</div>
);
};
export default BuildTab;