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.

packages/server/src/db/schema/index.ts

@@ -15,6 +15,7 @@ export * from "./gitea";
 export * from "./github";
 export * from "./gitlab";
 export * from "./libsql";
+export * from "./managed-server";
 export * from "./mariadb";
 export * from "./mongo";
 export * from "./mount";

packages/server/src/db/schema/managed-server.ts

@@ -0,0 +1,72 @@
+import { relations } from "drizzle-orm";
+import { integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { organization } from "./account";
+import { server } from "./server";
+
+export const managedServerStatus = pgEnum("managedServerStatus", [
+	"pending",
+	"provisioning",
+	"configuring",
+	"ready",
+	"error",
+	"terminating",
+	"terminated",
+]);
+
+export const managedServer = pgTable("managed_server", {
+	managedServerId: text("managedServerId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	organizationId: text("organizationId")
+		.notNull()
+		.references(() => organization.id, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "set null",
+	}),
+	/** Hostinger catalog item id, e.g. "hostingercom-vps-kvm2" */
+	plan: text("plan").notNull(),
+	status: managedServerStatus("status").notNull().default("pending"),
+	hostingerVmId: integer("hostingerVmId"),
+	hostingerSubscriptionId: text("hostingerSubscriptionId"),
+	dataCenterId: integer("dataCenterId").notNull(),
+	ipAddress: text("ipAddress"),
+	hostname: text("hostname"),
+	stripeSubscriptionId: text("stripeSubscriptionId"),
+	stripePriceId: text("stripePriceId"),
+	rootPassword: text("rootPassword"),
+	errorMessage: text("errorMessage"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	updatedAt: text("updatedAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const managedServerRelations = relations(managedServer, ({ one }) => ({
+	organization: one(organization, {
+		fields: [managedServer.organizationId],
+		references: [organization.id],
+	}),
+	server: one(server, {
+		fields: [managedServer.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+export const apiCreateManagedServer = z.object({
+	plan: z.string().min(1),
+	dataCenterId: z.number().int().positive(),
+	isAnnual: z.boolean().default(false),
+});
+
+export const apiFindOneManagedServer = z.object({
+	managedServerId: z.string().min(1),
+});
+
+export const apiDeleteManagedServer = z.object({
+	managedServerId: z.string().min(1),
+});

packages/server/src/index.ts

@@ -43,6 +43,7 @@ export * from "./services/registry";
 export * from "./services/rollbacks";
 export * from "./services/schedule";
 export * from "./services/security";
+export * from "./services/managed-server";
 export * from "./services/server";
 export * from "./services/settings";
 export * from "./services/ssh-key";

packages/server/src/services/managed-server.ts

@@ -0,0 +1,54 @@
+import { db } from "@dokploy/server/db";
+import { managedServer } from "@dokploy/server/db/schema/managed-server";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type ManagedServer = typeof managedServer.$inferSelect;
+
+export const createManagedServer = async (
+	input: typeof managedServer.$inferInsert,
+) => {
+	const record = await db
+		.insert(managedServer)
+		.values(input)
+		.returning()
+		.then((r) => r[0]);
+	if (!record) throw new TRPCError({ code: "INTERNAL_SERVER_ERROR" });
+	return record;
+};
+
+export const findManagedServerById = async (managedServerId: string) => {
+	const record = await db.query.managedServer.findFirst({
+		where: eq(managedServer.managedServerId, managedServerId),
+		with: { server: true },
+	});
+	if (!record)
+		throw new TRPCError({ code: "NOT_FOUND", message: "Managed server not found" });
+	return record;
+};
+
+export const findManagedServersByOrg = async (organizationId: string) => {
+	return db.query.managedServer.findMany({
+		where: eq(managedServer.organizationId, organizationId),
+		with: { server: true },
+		orderBy: (t, { desc }) => [desc(t.createdAt)],
+	});
+};
+
+export const updateManagedServer = async (
+	managedServerId: string,
+	data: Partial<typeof managedServer.$inferInsert>,
+) => {
+	return db
+		.update(managedServer)
+		.set({ ...data, updatedAt: new Date().toISOString() })
+		.where(eq(managedServer.managedServerId, managedServerId))
+		.returning()
+		.then((r) => r[0]);
+};
+
+export const deleteManagedServer = async (managedServerId: string) => {
+	return db
+		.delete(managedServer)
+		.where(eq(managedServer.managedServerId, managedServerId));
+};

packages/server/src/utils/hostinger.ts

@@ -0,0 +1,155 @@
+import {
+	BillingCatalogApi,
+	Configuration,
+	VPSDataCentersApi,
+	VPSVirtualMachineApi,
+} from "hostinger-api-sdk";
+
+export type {
+	BillingV1CatalogCatalogItemResource as HostingerCatalogItem,
+	VPSV1DataCenterDataCenterResource as HostingerDataCenter,
+	VPSV1VirtualMachinePurchaseRequest as HostingerPurchaseRequest,
+	VPSV1VirtualMachineVirtualMachineResource as HostingerVM,
+} from "hostinger-api-sdk";
+
+// Correct base URL — api.hostinger.com returns 530, developers.hostinger.com is the real gateway
+const HOSTINGER_BASE_PATH = "https://developers.hostinger.com";
+
+function getConfig() {
+	const apiKey = process.env.HOSTINGER_API_KEY;
+	if (!apiKey) throw new Error("HOSTINGER_API_KEY is not set");
+	return new Configuration({
+		basePath: HOSTINGER_BASE_PATH,
+		accessToken: apiKey,
+	});
+}
+
+function getVmApi() {
+	return new VPSVirtualMachineApi(getConfig());
+}
+
+export async function getHostingerDataCenters() {
+	const api = new VPSDataCentersApi(getConfig());
+	const res = await api.getDataCenterListV1();
+	return res.data;
+}
+
+export async function getHostingerVpsCatalog() {
+	const api = new BillingCatalogApi(getConfig());
+	const res = await api.getCatalogItemListV1("VPS");
+	return res.data;
+}
+
+export async function purchaseHostingerVps(
+	body: import("hostinger-api-sdk").VPSV1VirtualMachinePurchaseRequest,
+) {
+	const api = getVmApi();
+	const res = await api.purchaseNewVirtualMachineV1(body);
+	return res.data;
+}
+
+export async function getHostingerVm(vmId: number) {
+	const api = getVmApi();
+	const res = await api.getVirtualMachineDetailsV1(vmId);
+	return res.data;
+}
+
+export async function stopHostingerVm(vmId: number) {
+	const api = getVmApi();
+	await api.stopVirtualMachineV1(vmId);
+}
+
+/** Ubuntu 22.04 LTS template ID on Hostinger */
+export const UBUNTU_22_TEMPLATE_ID = 1009;
+
+/**
+ * Markup multiplier applied to Hostinger's catalog price to get Dokploy's user price.
+ * Hostinger KVM2 = ~$24.49/mo → Dokploy charges $45/mo (~84% markup).
+ */
+const MARKUP = 1.84;
+
+export interface ManagedServerPlan {
+	id: string;
+	name: string;
+	hostingerItemIdMonthly: string;
+	hostingerItemIdAnnual: string;
+	cpus: number;
+	memoryMb: number;
+	diskMb: number;
+	bandwidthMb: number;
+	/** Price in cents Hostinger charges us monthly */
+	hostingerPriceCentsMonthly: number;
+	/** Price in cents we charge the user monthly */
+	dokployPriceCentsMonthly: number;
+	/** Price in cents we charge the user annually */
+	dokployPriceCentsAnnual: number;
+}
+
+/** KVM plan IDs offered through Dokploy (excludes Game Panel plans) */
+const OFFERED_PLAN_IDS = ["hostingercom-vps-kvm1", "hostingercom-vps-kvm2", "hostingercom-vps-kvm4", "hostingercom-vps-kvm8"];
+
+/**
+ * Fetches live VPS plans from Hostinger catalog and applies Dokploy markup.
+ * Only returns standard KVM plans (not Game Panel variants).
+ */
+export async function getManagedServerPlans(): Promise<ManagedServerPlan[]> {
+	const catalog = await getHostingerVpsCatalog();
+
+	const plans: ManagedServerPlan[] = [];
+
+	for (const item of catalog) {
+		if (!OFFERED_PLAN_IDS.includes(item.id ?? "")) continue;
+
+		const meta = item.metadata as Record<string, string> | null;
+		const cpus = Number(meta?.cpus ?? 0);
+		const memoryMb = Number(meta?.memory ?? 0);
+		const diskMb = Number(meta?.disk_space ?? 0);
+		const bandwidthMb = Number(meta?.bandwidth ?? 0);
+
+		const monthlyPrice = item.prices?.find(
+			(p) => p.period === 1 && p.period_unit === "month",
+		);
+		const annualPrice = item.prices?.find(
+			(p) => p.period === 1 && p.period_unit === "year",
+		);
+
+		if (!monthlyPrice) continue;
+
+		const hostingerMonthly = monthlyPrice.price ?? 0;
+		const hostingerAnnual = annualPrice?.price ?? hostingerMonthly * 12;
+
+		// Apply markup and round to nearest $0.50 (50 cents)
+		const dokployMonthly = Math.ceil((hostingerMonthly * MARKUP) / 50) * 50;
+		const dokployAnnual = Math.ceil((hostingerAnnual * MARKUP) / 50) * 50;
+
+		// Derive hostinger item IDs for monthly and annual billing
+		const hostingerItemIdMonthly = monthlyPrice.id ?? `${item.id}-usd-1m`;
+		const hostingerItemIdAnnual = annualPrice?.id ?? `${item.id}-usd-1y`;
+
+		// Map hostinger plan names to friendly names
+		const friendlyNames: Record<string, string> = {
+			"hostingercom-vps-kvm1": "Starter",
+			"hostingercom-vps-kvm2": "Basic",
+			"hostingercom-vps-kvm4": "Growth",
+			"hostingercom-vps-kvm8": "Scale",
+		};
+
+		plans.push({
+			id: item.id ?? "",
+			name: friendlyNames[item.id ?? ""] ?? item.name ?? item.id ?? "",
+			hostingerItemIdMonthly,
+			hostingerItemIdAnnual,
+			cpus,
+			memoryMb,
+			diskMb,
+			bandwidthMb,
+			hostingerPriceCentsMonthly: hostingerMonthly,
+			dokployPriceCentsMonthly: dokployMonthly,
+			dokployPriceCentsAnnual: dokployAnnual,
+		});
+	}
+
+	return plans;
+}
+
+export type ManagedServerPlanId = string;