feat(managed-servers): add managed servers functionality and API integration

- Introduced a new API for managing servers, including endpoints for listing, purchasing, and retrieving server plans. - Added a new page and components for displaying managed servers in the dashboard. - Updated the sidebar to include navigation for managed servers. - Created database migrations for managed server types and status. - Enhanced environment configuration with a new API key for Hostinger services. This update enables users to manage their servers directly from the Dokploy dashboard, improving the overall user experience and functionality.
2026-07-28 01:05:25 +02:00 · 2026-05-05 08:10:30 -06:00
parent 9b416b3699
commit 299950a323
20 changed files with 26499 additions and 29 deletions
--- a/apps/dokploy/.env.example
+++ b/apps/dokploy/.env.example
@@ -1,3 +1,6 @@
 DATABASE_URL="postgres://dokploy:amukds4wi9001583845717ad2@localhost:5432/dokploy"
 PORT=3000
 NODE_ENV=development
+
+# Managed Servers (Dokploy Cloud only) — API token from https://hpanel.hostinger.com/profile/api
+HOSTINGER_API_KEY=
--- a/apps/dokploy/components/dashboard/settings/billing/show-billing-invoices.tsx
+++ b/apps/dokploy/components/dashboard/settings/billing/show-billing-invoices.tsx
@@ -1,4 +1,4 @@
-import { CreditCard, FileText } from "lucide-react";
+import { CreditCard, FileText, Server } from "lucide-react";
 import Link from "next/link";
 import { useRouter } from "next/router";
 import {
@@ -17,6 +17,11 @@ const navigationItems = [
 		href: "/dashboard/settings/billing",
 		icon: CreditCard,
 	},
+	{
+		name: "Managed Servers",
+		href: "/dashboard/settings/managed-servers",
+		icon: Server,
+	},
 	{
 		name: "Invoices",
 		href: "/dashboard/settings/invoices",
--- a/apps/dokploy/components/dashboard/settings/billing/show-billing.tsx
+++ b/apps/dokploy/components/dashboard/settings/billing/show-billing.tsx
@@ -9,6 +9,7 @@ import {
 	Loader2,
 	MinusIcon,
 	PlusIcon,
+	Server,
 	ShieldCheck,
 } from "lucide-react";
 import Link from "next/link";
@@ -82,6 +83,11 @@ const navigationItems = [
 		href: "/dashboard/settings/billing",
 		icon: CreditCard,
 	},
+	{
+		name: "Managed Servers",
+		href: "/dashboard/settings/managed-servers",
+		icon: Server,
+	},
 	{
 		name: "Invoices",
 		href: "/dashboard/settings/invoices",
--- a/apps/dokploy/components/dashboard/settings/billing/show-managed-servers.tsx
+++ b/apps/dokploy/components/dashboard/settings/billing/show-managed-servers.tsx
@@ -0,0 +1,493 @@
+import {
+	AlertCircle,
+	CheckCircle2,
+	Clock,
+	CreditCard,
+	ExternalLink,
+	FileText,
+	Loader2,
+	Plus,
+	Server,
+	Trash2,
+	XCircle,
+} from "lucide-react";
+import Link from "next/link";
+import { useRouter } from "next/router";
+import { useState } from "react";
+import { toast } from "sonner";
+import { DialogAction } from "@/components/shared/dialog-action";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+import { api } from "@/utils/api";
+
+const navigationItems = [
+	{
+		name: "Subscription",
+		href: "/dashboard/settings/billing",
+		icon: CreditCard,
+	},
+	{
+		name: "Managed Servers",
+		href: "/dashboard/settings/managed-servers",
+		icon: Server,
+	},
+	{
+		name: "Invoices",
+		href: "/dashboard/settings/invoices",
+		icon: FileText,
+	},
+];
+
+const STATUS_MAP: Record<
+	string,
+	{
+		label: string;
+		icon: React.ReactNode;
+		variant: "default" | "secondary" | "destructive" | "outline";
+	}
+> = {
+	pending: {
+		label: "Pending",
+		icon: <Clock className="size-3" />,
+		variant: "secondary",
+	},
+	provisioning: {
+		label: "Provisioning",
+		icon: <Loader2 className="size-3 animate-spin" />,
+		variant: "secondary",
+	},
+	configuring: {
+		label: "Installing Dokploy",
+		icon: <Loader2 className="size-3 animate-spin" />,
+		variant: "secondary",
+	},
+	ready: {
+		label: "Ready",
+		icon: <CheckCircle2 className="size-3" />,
+		variant: "default",
+	},
+	error: {
+		label: "Error",
+		icon: <XCircle className="size-3" />,
+		variant: "destructive",
+	},
+	terminating: {
+		label: "Terminating",
+		icon: <Loader2 className="size-3 animate-spin" />,
+		variant: "secondary",
+	},
+	terminated: {
+		label: "Terminated",
+		icon: <AlertCircle className="size-3" />,
+		variant: "outline",
+	},
+};
+
+function formatSpecs(cpus: number, memoryMb: number, diskMb: number, bandwidthMb: number) {
+	const bandwidthTb = bandwidthMb / 1024 / 1024;
+	const bandwidthLabel = bandwidthTb >= 1 ? `${bandwidthTb.toFixed(0)} TB` : `${Math.round(bandwidthMb / 1024)} GB`;
+	return `${cpus} vCPU · ${Math.round(memoryMb / 1024)} GB RAM · ${Math.round(diskMb / 1024)} GB NVMe · ${bandwidthLabel} bandwidth`;
+}
+
+function centsToDisplay(cents: number) {
+	return (cents / 100).toFixed(2).replace(/\.00$/, "");
+}
+
+function OrderServerDialog({ onSuccess }: { onSuccess: () => void }) {
+	const [open, setOpen] = useState(false);
+	const [selectedPlan, setSelectedPlan] = useState<string>("");
+	const [selectedDc, setSelectedDc] = useState<string>("");
+	const [isAnnual, setIsAnnual] = useState(false);
+
+	const { data: plans, isLoading: loadingPlans } =
+		api.managedServer.getPlans.useQuery(undefined, { enabled: open });
+	const { data: dataCenters, isLoading: loadingDcs } =
+		api.managedServer.getDataCenters.useQuery(undefined, { enabled: open });
+
+	const isLoadingOptions = loadingPlans || loadingDcs;
+
+	const purchase = api.managedServer.purchase.useMutation({
+		onSuccess: () => {
+			toast.success("Server order placed! Provisioning will take ~5 minutes.");
+			setOpen(false);
+			onSuccess();
+		},
+		onError: (err) => {
+			toast.error(err.message);
+		},
+	});
+
+	const plan = plans?.find((p) => p.id === selectedPlan);
+
+	const displayPrice = (p: NonNullable<typeof plan>) =>
+		isAnnual
+			? `$${centsToDisplay(p.dokployPriceCentsAnnual)}/yr`
+			: `$${centsToDisplay(p.dokployPriceCentsMonthly)}/mo`;
+
+	const displayPriceSmall = (p: NonNullable<typeof plan>) =>
+		isAnnual
+			? `$${centsToDisplay(Math.round(p.dokployPriceCentsAnnual / 12))}/mo billed annually`
+			: `$${centsToDisplay(p.dokployPriceCentsAnnual)}/yr if annual`;
+
+	return (
+		<Dialog open={open} onOpenChange={setOpen}>
+			<DialogTrigger asChild>
+				<Button size="sm">
+					<Plus className="size-4 mr-2" />
+					Order Server
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="max-w-lg max-h-[90vh] overflow-y-auto">
+				<DialogHeader>
+					<DialogTitle>Order a Managed Server</DialogTitle>
+					<DialogDescription>
+						We'll provision and configure a server for you automatically. Ready
+						in ~5 minutes.
+					</DialogDescription>
+				</DialogHeader>
+
+				<div className="space-y-4 pt-2">
+					{isLoadingOptions ? (
+						<div className="flex flex-col items-center justify-center py-8 gap-3 text-muted-foreground">
+							<Loader2 className="size-6 animate-spin" />
+							<p className="text-sm">Loading available plans...</p>
+						</div>
+					) : (
+						<div className="space-y-4">
+							{/* Billing period toggle */}
+							<div className="flex items-center gap-1 rounded-lg border p-1 bg-muted/40 w-fit">
+								<button
+									type="button"
+									onClick={() => setIsAnnual(false)}
+									className={cn(
+										"px-4 py-1.5 rounded-md text-sm font-medium transition-colors",
+										!isAnnual
+											? "bg-background shadow-sm text-foreground"
+											: "text-muted-foreground hover:text-foreground",
+									)}
+								>
+									Monthly
+								</button>
+								<button
+									type="button"
+									onClick={() => setIsAnnual(true)}
+									className={cn(
+										"px-4 py-1.5 rounded-md text-sm font-medium transition-colors flex items-center gap-1.5",
+										isAnnual
+											? "bg-background shadow-sm text-foreground"
+											: "text-muted-foreground hover:text-foreground",
+									)}
+								>
+									Annual
+									<span className="text-xs bg-green-500/15 text-green-600 dark:text-green-400 px-1.5 py-0.5 rounded font-semibold">
+										Save ~20%
+									</span>
+								</button>
+							</div>
+
+							{/* Plan selector */}
+							<div className="space-y-2">
+								<Label>Plan</Label>
+								<div className="grid gap-2">
+									{plans?.map((p) => (
+										<button
+											key={p.id}
+											type="button"
+											onClick={() => setSelectedPlan(p.id)}
+											className={cn(
+												"flex items-center justify-between rounded-lg border p-3 text-left transition-colors",
+												selectedPlan === p.id
+													? "border-primary bg-primary/5"
+													: "border-border hover:border-muted-foreground",
+											)}
+										>
+											<div>
+												<p className="font-medium text-sm">{p.name}</p>
+												<p className="text-xs text-muted-foreground">
+													{formatSpecs(p.cpus, p.memoryMb, p.diskMb, p.bandwidthMb)}
+												</p>
+											</div>
+											<div className="text-right">
+												<p className="font-semibold text-sm">
+													{displayPrice(p)}
+												</p>
+												<p className="text-xs text-muted-foreground">
+													{displayPriceSmall(p)}
+												</p>
+											</div>
+										</button>
+									))}
+								</div>
+							</div>
+
+							{/* Data center selector */}
+							<div className="space-y-2">
+								<Label>Data Center</Label>
+								<Select value={selectedDc} onValueChange={setSelectedDc}>
+									<SelectTrigger>
+										<SelectValue placeholder="Select a location..." />
+									</SelectTrigger>
+									<SelectContent position="popper" side="bottom" sideOffset={4} className="max-h-56 overflow-y-auto">
+										{dataCenters?.map((dc) => (
+											<SelectItem key={dc.id} value={String(dc.id)}>
+												{dc.city} — {dc.continent}
+											</SelectItem>
+										))}
+									</SelectContent>
+								</Select>
+							</div>
+
+							{plan && selectedDc && (
+								<div className="rounded-lg bg-muted p-3 text-sm space-y-1">
+									<div className="flex justify-between">
+										<span className="text-muted-foreground">Plan</span>
+										<span className="font-medium">{plan.name}</span>
+									</div>
+									<div className="flex justify-between">
+										<span className="text-muted-foreground">Billing</span>
+										<span className="font-medium">{isAnnual ? "Annual" : "Monthly"}</span>
+									</div>
+									<div className="flex justify-between">
+										<span className="text-muted-foreground">Total</span>
+										<span className="font-semibold">{displayPrice(plan)}</span>
+									</div>
+								</div>
+							)}
+
+							<Button
+								className="w-full"
+								disabled={!selectedPlan || !selectedDc || purchase.isPending}
+								onClick={() => {
+									if (!selectedPlan || !selectedDc) return;
+									purchase.mutate({
+										plan: selectedPlan,
+										dataCenterId: Number(selectedDc),
+										isAnnual,
+									});
+								}}
+							>
+								{purchase.isPending ? (
+									<>
+										<Loader2 className="size-4 mr-2 animate-spin" />
+										Placing order...
+									</>
+								) : (
+									"Order Server"
+								)}
+							</Button>
+						</div>
+					)}
+				</div>
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+export const ShowManagedServers = () => {
+	const router = useRouter();
+	const utils = api.useUtils();
+
+	const { data: servers, isLoading } = api.managedServer.list.useQuery();
+
+	const syncStatus = api.managedServer.syncStatus.useMutation({
+		onSuccess: () => utils.managedServer.list.invalidate(),
+	});
+
+	const deleteServer = api.managedServer.delete.useMutation({
+		onSuccess: () => {
+			toast.success("Server terminated.");
+			utils.managedServer.list.invalidate();
+		},
+		onError: (err) => toast.error(err.message),
+	});
+
+	return (
+		<div className="w-full">
+			<Card className="bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
+				<div className="rounded-xl bg-background shadow-md">
+					<CardHeader>
+						<CardTitle className="text-xl flex flex-row gap-2">
+							<Server className="size-6 text-muted-foreground self-center" />
+							Billing
+						</CardTitle>
+						<CardDescription>
+							Manage your subscription and servers
+						</CardDescription>
+					</CardHeader>
+					<CardContent className="space-y-4 py-4 border-t">
+						<nav className="flex space-x-2 border-b">
+							{navigationItems.map((item) => {
+								const Icon = item.icon;
+								const isActive = router.pathname === item.href;
+								return (
+									<Link
+										key={item.name}
+										href={item.href}
+										className={cn(
+											"flex items-center gap-2 px-4 py-2 text-sm font-medium border-b-2 transition-colors",
+											isActive
+												? "border-primary text-primary"
+												: "border-transparent text-muted-foreground hover:text-primary hover:border-muted",
+										)}
+									>
+										<Icon className="h-4 w-4" />
+										{item.name}
+									</Link>
+								);
+							})}
+						</nav>
+
+						<div className="mt-6 space-y-4">
+							<div className="flex items-center justify-between">
+								<div>
+									<h3 className="font-semibold text-base">Managed Servers</h3>
+									<p className="text-sm text-muted-foreground">
+										Servers provisioned and managed by Dokploy Cloud
+									</p>
+								</div>
+								<OrderServerDialog
+									onSuccess={() => utils.managedServer.list.invalidate()}
+								/>
+							</div>
+
+							{isLoading ? (
+								<div className="flex justify-center py-8">
+									<Loader2 className="size-6 animate-spin text-muted-foreground" />
+								</div>
+							) : servers?.length === 0 ? (
+								<div className="text-center py-12 border rounded-lg border-dashed">
+									<Server className="size-10 mx-auto text-muted-foreground mb-3" />
+									<p className="text-sm font-medium">No managed servers yet</p>
+									<p className="text-xs text-muted-foreground mt-1">
+										Order a server and we'll provision and configure it for you
+										automatically.
+									</p>
+								</div>
+							) : (
+								<div className="space-y-3">
+									{servers?.map((s) => {
+										const status =
+											STATUS_MAP[s.status] ?? STATUS_MAP.error!;
+										const isProvisioning = [
+											"pending",
+											"provisioning",
+											"configuring",
+										].includes(s.status);
+										const planLabel = s.plan
+											.split("-")
+											.slice(-2)
+											.join(" ")
+											.toUpperCase();
+
+										return (
+											<div
+												key={s.managedServerId}
+												className="flex items-center justify-between rounded-lg border p-4"
+											>
+												<div className="flex items-center gap-3">
+													<Server className="size-5 text-muted-foreground shrink-0" />
+													<div className="space-y-0.5">
+														<div className="flex items-center gap-2">
+															<span className="font-medium text-sm">
+																{planLabel}
+															</span>
+															<Badge
+																variant={status?.variant}
+																className="flex items-center gap-1 text-xs h-5"
+															>
+																{status?.icon}
+																{status?.label}
+															</Badge>
+														</div>
+														<p className="text-xs text-muted-foreground">
+															{s.hostname ?? ""}
+															{s.ipAddress ? ` · ${s.ipAddress}` : ""}
+														</p>
+													</div>
+												</div>
+
+												<div className="flex items-center gap-2">
+													{isProvisioning && (
+														<Button
+															variant="ghost"
+															size="sm"
+															onClick={() =>
+																syncStatus.mutate({
+																	managedServerId: s.managedServerId,
+																})
+															}
+															disabled={syncStatus.isPending}
+														>
+															<Loader2
+																className={cn(
+																	"size-4",
+																	syncStatus.isPending && "animate-spin",
+																)}
+															/>
+														</Button>
+													)}
+													{s.status === "ready" && s.server && (
+														<Button variant="outline" size="sm" asChild>
+															<Link
+																href={`/dashboard/settings/server?serverId=${s.serverId}`}
+															>
+																<ExternalLink className="size-3.5 mr-1.5" />
+																Open
+															</Link>
+														</Button>
+													)}
+													<DialogAction
+														title="Terminate Server"
+														description="This will permanently destroy the server and all data on it. This action cannot be undone."
+														type="destructive"
+														onClick={() =>
+															deleteServer.mutate({
+																managedServerId: s.managedServerId,
+															})
+														}
+													>
+														<Button
+															variant="ghost"
+															size="sm"
+															className="text-destructive hover:text-destructive"
+														>
+															<Trash2 className="size-4" />
+														</Button>
+													</DialogAction>
+												</div>
+											</div>
+										);
+									})}
+								</div>
+							)}
+						</div>
+					</CardContent>
+				</div>
+			</Card>
+		</div>
+	);
+};
--- a/apps/dokploy/drizzle/0166_lame_meltdown.sql
+++ b/apps/dokploy/drizzle/0166_lame_meltdown.sql
@@ -0,0 +1,23 @@
+CREATE TYPE "public"."managedServerPlan" AS ENUM('kvm2', 'kvm4', 'kvm8');--> statement-breakpoint
+CREATE TYPE "public"."managedServerStatus" AS ENUM('pending', 'provisioning', 'configuring', 'ready', 'error', 'terminating', 'terminated');--> statement-breakpoint
+CREATE TABLE "managed_server" (
+	"managedServerId" text PRIMARY KEY NOT NULL,
+	"organizationId" text NOT NULL,
+	"serverId" text,
+	"plan" "managedServerPlan" NOT NULL,
+	"status" "managedServerStatus" DEFAULT 'pending' NOT NULL,
+	"hostingerVmId" integer,
+	"hostingerSubscriptionId" text,
+	"dataCenterId" integer NOT NULL,
+	"ipAddress" text,
+	"hostname" text,
+	"stripeSubscriptionId" text,
+	"stripePriceId" text,
+	"rootPassword" text,
+	"errorMessage" text,
+	"createdAt" text NOT NULL,
+	"updatedAt" text NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "managed_server" ADD CONSTRAINT "managed_server_organizationId_organization_id_fk" FOREIGN KEY ("organizationId") REFERENCES "public"."organization"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "managed_server" ADD CONSTRAINT "managed_server_serverId_server_serverId_fk" FOREIGN KEY ("serverId") REFERENCES "public"."server"("serverId") ON DELETE set null ON UPDATE no action;
--- a/apps/dokploy/drizzle/0167_cultured_captain_cross.sql
+++ b/apps/dokploy/drizzle/0167_cultured_captain_cross.sql
@@ -0,0 +1,2 @@
+ALTER TABLE "managed_server" ALTER COLUMN "plan" SET DATA TYPE text;--> statement-breakpoint
+DROP TYPE "public"."managedServerPlan";
--- a/apps/dokploy/drizzle/meta/0166_snapshot.json
+++ b/apps/dokploy/drizzle/meta/0166_snapshot.json
--- a/apps/dokploy/drizzle/meta/0167_snapshot.json
+++ b/apps/dokploy/drizzle/meta/0167_snapshot.json
--- a/apps/dokploy/drizzle/meta/_journal.json
+++ b/apps/dokploy/drizzle/meta/_journal.json
@@ -1163,6 +1163,20 @@
      "when": 1775845419261,
      "tag": "0165_abnormal_greymalkin",
      "breakpoints": true
+    },
+    {
+      "idx": 166,
+      "version": "7",
+      "when": 1777967101978,
+      "tag": "0166_lame_meltdown",
+      "breakpoints": true
+    },
+    {
+      "idx": 167,
+      "version": "7",
+      "when": 1777967443440,
+      "tag": "0167_cultured_captain_cross",
+      "breakpoints": true
    }
  ]
 }
--- a/apps/dokploy/pages/dashboard/settings/managed-servers.tsx
+++ b/apps/dokploy/pages/dashboard/settings/managed-servers.tsx
@@ -0,0 +1,39 @@
+import { IS_CLOUD } from "@dokploy/server/constants";
+import { validateRequest } from "@dokploy/server/lib/auth";
+import type { GetServerSidePropsContext } from "next";
+import type { ReactElement } from "react";
+import { ShowManagedServers } from "@/components/dashboard/settings/billing/show-managed-servers";
+import { DashboardLayout } from "@/components/layouts/dashboard-layout";
+
+const Page = () => {
+	return <ShowManagedServers />;
+};
+
+export default Page;
+
+Page.getLayout = (page: ReactElement) => {
+	return <DashboardLayout metaName="Managed Servers">{page}</DashboardLayout>;
+};
+
+export async function getServerSideProps(
+	ctx: GetServerSidePropsContext,
+) {
+	if (!IS_CLOUD) {
+		return {
+			redirect: {
+				permanent: false,
+				destination: "/dashboard/home",
+			},
+		};
+	}
+	const { user } = await validateRequest(ctx.req);
+	if (!user || user.role !== "owner") {
+		return {
+			redirect: {
+				permanent: false,
+				destination: "/",
+			},
+		};
+	}
+	return { props: {} };
+}
--- a/apps/dokploy/server/api/root.ts
+++ b/apps/dokploy/server/api/root.ts
@@ -31,6 +31,7 @@ import { projectRouter } from "./routers/project";
 import { auditLogRouter } from "./routers/proprietary/audit-log";
 import { customRoleRouter } from "./routers/proprietary/custom-role";
 import { licenseKeyRouter } from "./routers/proprietary/license-key";
+import { managedServerRouter } from "./routers/proprietary/managed-server";
 import { ssoRouter } from "./routers/proprietary/sso";
 import { whitelabelingRouter } from "./routers/proprietary/whitelabeling";
 import { redirectsRouter } from "./routers/redirects";
@@ -102,6 +103,7 @@ export const appRouter = createTRPCRouter({
 	environment: environmentRouter,
 	tag: tagRouter,
 	patch: patchRouter,
+	managedServer: managedServerRouter,
 });

 // export type definition of API
--- a/apps/dokploy/server/api/routers/proprietary/managed-server.ts
+++ b/apps/dokploy/server/api/routers/proprietary/managed-server.ts
@@ -0,0 +1,247 @@
+import {
+	createServer,
+	IS_CLOUD,
+	serverSetup,
+} from "@dokploy/server";
+import {
+	apiCreateManagedServer,
+	apiDeleteManagedServer,
+	apiFindOneManagedServer,
+} from "@dokploy/server/db/schema/managed-server";
+import {
+	createManagedServer,
+	deleteManagedServer,
+	findManagedServerById,
+	findManagedServersByOrg,
+	updateManagedServer,
+} from "@dokploy/server/services/managed-server";
+import {
+	getHostingerDataCenters,
+	getHostingerVm,
+	getManagedServerPlans,
+	purchaseHostingerVps,
+	stopHostingerVm,
+	UBUNTU_22_TEMPLATE_ID,
+} from "@dokploy/server/utils/hostinger";
+import { TRPCError } from "@trpc/server";
+import { nanoid } from "nanoid";
+import { adminProcedure, createTRPCRouter } from "../../trpc";
+
+export const managedServerRouter = createTRPCRouter({
+	getPlans: adminProcedure.query(async () => {
+		if (!IS_CLOUD) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Managed servers are only available in Dokploy Cloud",
+			});
+		}
+		return getManagedServerPlans();
+	}),
+
+	getDataCenters: adminProcedure.query(async () => {
+		if (!IS_CLOUD) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Managed servers are only available in Dokploy Cloud",
+			});
+		}
+		return getHostingerDataCenters();
+	}),
+
+	list: adminProcedure.query(async ({ ctx }) => {
+		if (!IS_CLOUD) return [];
+		return findManagedServersByOrg(ctx.session.activeOrganizationId);
+	}),
+
+	one: adminProcedure
+		.input(apiFindOneManagedServer)
+		.query(async ({ input, ctx }) => {
+			if (!IS_CLOUD) {
+				throw new TRPCError({ code: "BAD_REQUEST", message: "Cloud only" });
+			}
+			const record = await findManagedServerById(input.managedServerId);
+			if (record.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({ code: "UNAUTHORIZED" });
+			}
+			return record;
+		}),
+
+	purchase: adminProcedure
+		.input(apiCreateManagedServer)
+		.mutation(async ({ input, ctx }) => {
+			if (!IS_CLOUD) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "Managed servers are only available in Dokploy Cloud",
+				});
+			}
+
+			const plans = await getManagedServerPlans();
+			const plan = plans.find((p) => p.id === input.plan);
+			if (!plan) {
+				throw new TRPCError({ code: "BAD_REQUEST", message: "Invalid plan" });
+			}
+
+			const hostname =
+				`dokploy-${ctx.session.activeOrganizationId.slice(0, 8)}-${nanoid(6)}`.toLowerCase();
+
+			const managedRecord = await createManagedServer({
+				organizationId: ctx.session.activeOrganizationId,
+				plan: input.plan,
+				dataCenterId: input.dataCenterId,
+				status: "provisioning",
+			});
+
+			const hostingerItemId = input.isAnnual
+				? plan.hostingerItemIdAnnual
+				: plan.hostingerItemIdMonthly;
+
+			provisionManagedServer(
+				managedRecord.managedServerId,
+				hostingerItemId,
+				input.dataCenterId,
+				hostname,
+				ctx.session.activeOrganizationId,
+			).catch(async (err) => {
+				await updateManagedServer(managedRecord.managedServerId, {
+					status: "error",
+					errorMessage: err?.message ?? "Unknown error during provisioning",
+				});
+			});
+
+			return managedRecord;
+		}),
+
+	delete: adminProcedure
+		.input(apiDeleteManagedServer)
+		.mutation(async ({ input, ctx }) => {
+			if (!IS_CLOUD) {
+				throw new TRPCError({ code: "BAD_REQUEST", message: "Cloud only" });
+			}
+			const record = await findManagedServerById(input.managedServerId);
+			if (record.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({ code: "UNAUTHORIZED" });
+			}
+
+			await updateManagedServer(input.managedServerId, {
+				status: "terminating",
+			});
+
+			if (record.hostingerVmId) {
+				try {
+					await stopHostingerVm(record.hostingerVmId);
+				} catch (_) {
+					// Best-effort
+				}
+			}
+
+			await deleteManagedServer(input.managedServerId);
+			return { ok: true };
+		}),
+
+	syncStatus: adminProcedure
+		.input(apiFindOneManagedServer)
+		.mutation(async ({ input, ctx }) => {
+			if (!IS_CLOUD) {
+				throw new TRPCError({ code: "BAD_REQUEST", message: "Cloud only" });
+			}
+			const record = await findManagedServerById(input.managedServerId);
+			if (record.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({ code: "UNAUTHORIZED" });
+			}
+			if (!record.hostingerVmId) return record;
+
+			const vm = await getHostingerVm(record.hostingerVmId);
+			const ipAddress = vm.ipv4?.[0]?.address ?? record.ipAddress;
+
+			await updateManagedServer(input.managedServerId, {
+				ipAddress: ipAddress ?? undefined,
+				hostname: vm.hostname ?? undefined,
+				status:
+					vm.state === "running"
+						? record.serverId
+							? "ready"
+							: "configuring"
+						: record.status,
+			});
+
+			return findManagedServerById(input.managedServerId);
+		}),
+});
+
+async function provisionManagedServer(
+	managedServerId: string,
+	hostingerItemId: string,
+	dataCenterId: number,
+	hostname: string,
+	organizationId: string,
+) {
+	const result = await purchaseHostingerVps({
+		item_id: hostingerItemId,
+		payment_method_id: 0,
+		setup: {
+			template_id: UBUNTU_22_TEMPLATE_ID,
+			data_center_id: dataCenterId,
+			hostname,
+			enable_backups: false,
+		},
+		coupons: [],
+	});
+
+	const vm = result.virtual_machine;
+
+	await updateManagedServer(managedServerId, {
+		hostingerVmId: vm.id,
+		hostingerSubscriptionId: vm.subscription_id ?? undefined,
+		ipAddress: vm.ipv4?.[0]?.address ?? undefined,
+		hostname: vm.hostname ?? undefined,
+		status: "configuring",
+	});
+
+	await waitForVmRunning(vm.id!, managedServerId);
+
+	const finalVm = await getHostingerVm(vm.id!);
+	const finalIp = finalVm.ipv4?.[0]?.address;
+
+	if (!finalIp) {
+		throw new Error("VM is running but has no IPv4 address");
+	}
+
+	const serverRecord = await createServer(
+		{
+			name: `Managed • ${hostname}`,
+			description: "Managed server provisioned by Dokploy Cloud",
+			ipAddress: finalIp,
+			port: 22,
+			username: "root",
+			serverType: "deploy",
+		},
+		organizationId,
+	);
+
+	await updateManagedServer(managedServerId, {
+		serverId: serverRecord.serverId,
+		ipAddress: finalIp,
+	});
+
+	await serverSetup(serverRecord.serverId);
+
+	await updateManagedServer(managedServerId, { status: "ready" });
+}
+
+async function waitForVmRunning(
+	vmId: number,
+	_managedServerId: string,
+	maxAttempts = 30,
+	intervalMs = 10_000,
+) {
+	for (let i = 0; i < maxAttempts; i++) {
+		await new Promise((r) => setTimeout(r, intervalMs));
+		const vm = await getHostingerVm(vmId);
+		if (vm.state === "running") return;
+		if (vm.state === "error") {
+			throw new Error("VM entered error state");
+		}
+	}
+	throw new Error("Timed out waiting for VM to become running");
+}