chore: initial commit for phase07

apps/api/src/lib/config-parsers.ts

@@ -0,0 +1,234 @@
+import type { ConfigParser, ConfigEntry } from '@source/shared';
+
+/**
+ * Parse a config file content into key-value entries based on the parser type.
+ */
+export function parseConfig(content: string, parser: ConfigParser): ConfigEntry[] {
+  switch (parser) {
+    case 'properties':
+      return parseProperties(content);
+    case 'json':
+      return parseJson(content);
+    case 'yaml':
+      return parseYaml(content);
+    case 'keyvalue':
+      return parseKeyValue(content);
+    default:
+      return [];
+  }
+}
+
+/**
+ * Serialize key-value entries back into a config file content.
+ */
+export function serializeConfig(
+  entries: ConfigEntry[],
+  parser: ConfigParser,
+  originalContent?: string,
+): string {
+  switch (parser) {
+    case 'properties':
+      return serializeProperties(entries, originalContent);
+    case 'json':
+      return serializeJson(entries);
+    case 'yaml':
+      return serializeYaml(entries, originalContent);
+    case 'keyvalue':
+      return serializeKeyValue(entries, originalContent);
+    default:
+      return '';
+  }
+}
+
+// === Properties (Java .properties format) ===
+
+function parseProperties(content: string): ConfigEntry[] {
+  const entries: ConfigEntry[] = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) continue;
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) continue;
+    entries.push({
+      key: trimmed.substring(0, eqIndex).trim(),
+      value: trimmed.substring(eqIndex + 1).trim(),
+    });
+  }
+  return entries;
+}
+
+function serializeProperties(entries: ConfigEntry[], originalContent?: string): string {
+  if (!originalContent) {
+    return entries.map((e) => `${e.key}=${e.value}`).join('\n') + '\n';
+  }
+
+  const entryMap = new Map(entries.map((e) => [e.key, e.value]));
+  const lines = originalContent.split('\n');
+  const result: string[] = [];
+  const written = new Set<string>();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) {
+      result.push(line);
+      continue;
+    }
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) {
+      result.push(line);
+      continue;
+    }
+    const key = trimmed.substring(0, eqIndex).trim();
+    if (entryMap.has(key)) {
+      result.push(`${key}=${entryMap.get(key)}`);
+      written.add(key);
+    } else {
+      result.push(line);
+    }
+  }
+
+  // Append new keys
+  for (const entry of entries) {
+    if (!written.has(entry.key)) {
+      result.push(`${entry.key}=${entry.value}`);
+    }
+  }
+
+  return result.join('\n');
+}
+
+// === JSON ===
+
+function parseJson(content: string): ConfigEntry[] {
+  try {
+    const obj = JSON.parse(content);
+    if (typeof obj !== 'object' || Array.isArray(obj)) return [];
+    return Object.entries(obj).map(([key, value]) => ({
+      key,
+      value: typeof value === 'string' ? value : JSON.stringify(value),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function serializeJson(entries: ConfigEntry[]): string {
+  const obj: Record<string, unknown> = {};
+  for (const entry of entries) {
+    try {
+      obj[entry.key] = JSON.parse(entry.value);
+    } catch {
+      obj[entry.key] = entry.value;
+    }
+  }
+  return JSON.stringify(obj, null, 2) + '\n';
+}
+
+// === YAML (simplified — only top-level key: value) ===
+
+function parseYaml(content: string): ConfigEntry[] {
+  const entries: ConfigEntry[] = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    // Only handle top-level keys (no indentation)
+    if (line.startsWith(' ') || line.startsWith('\t')) continue;
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex === -1) continue;
+    const key = trimmed.substring(0, colonIndex).trim();
+    const value = trimmed.substring(colonIndex + 1).trim();
+    if (key) entries.push({ key, value });
+  }
+  return entries;
+}
+
+function serializeYaml(entries: ConfigEntry[], originalContent?: string): string {
+  if (!originalContent) {
+    return entries.map((e) => `${e.key}: ${e.value}`).join('\n') + '\n';
+  }
+
+  const entryMap = new Map(entries.map((e) => [e.key, e.value]));
+  const lines = originalContent.split('\n');
+  const result: string[] = [];
+  const written = new Set<string>();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || line.startsWith(' ') || line.startsWith('\t')) {
+      result.push(line);
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex === -1) {
+      result.push(line);
+      continue;
+    }
+    const key = trimmed.substring(0, colonIndex).trim();
+    if (entryMap.has(key)) {
+      result.push(`${key}: ${entryMap.get(key)}`);
+      written.add(key);
+    } else {
+      result.push(line);
+    }
+  }
+
+  for (const entry of entries) {
+    if (!written.has(entry.key)) {
+      result.push(`${entry.key}: ${entry.value}`);
+    }
+  }
+
+  return result.join('\n');
+}
+
+// === KeyValue (Source engine cfg: `key "value"` or `key value`) ===
+
+function parseKeyValue(content: string): ConfigEntry[] {
+  const entries: ConfigEntry[] = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//')) continue;
+
+    // Match: key "value" or key value
+    const match = trimmed.match(/^(\S+)\s+"([^"]*)"/) || trimmed.match(/^(\S+)\s+(.*)/);
+    if (match && match[1] && match[2] !== undefined) {
+      entries.push({ key: match[1], value: match[2] });
+    }
+  }
+  return entries;
+}
+
+function serializeKeyValue(entries: ConfigEntry[], originalContent?: string): string {
+  if (!originalContent) {
+    return entries.map((e) => `${e.key} "${e.value}"`).join('\n') + '\n';
+  }
+
+  const entryMap = new Map(entries.map((e) => [e.key, e.value]));
+  const lines = originalContent.split('\n');
+  const result: string[] = [];
+  const written = new Set<string>();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//')) {
+      result.push(line);
+      continue;
+    }
+    const match = trimmed.match(/^(\S+)\s+/);
+    const matchKey = match?.[1];
+    if (matchKey && entryMap.has(matchKey)) {
+      result.push(`${matchKey} "${entryMap.get(matchKey)}"`);
+      written.add(matchKey);
+    } else {
+      result.push(line);
+    }
+  }
+
+  for (const entry of entries) {
+    if (!written.has(entry.key)) {
+      result.push(`${entry.key} "${entry.value}"`);
+    }
+  }
+
+  return result.join('\n');
+}

apps/api/src/lib/schedule-utils.ts

@@ -0,0 +1,103 @@
+/**
+ * Compute the next run time for a scheduled task.
+ */
+export function computeNextRun(
+  scheduleType: string,
+  scheduleData: Record<string, unknown>,
+): Date {
+  const now = new Date();
+
+  switch (scheduleType) {
+    case 'interval': {
+      const minutes = Number(scheduleData.minutes) || 60;
+      return new Date(now.getTime() + minutes * 60_000);
+    }
+
+    case 'daily': {
+      const hour = Number(scheduleData.hour ?? 0);
+      const minute = Number(scheduleData.minute ?? 0);
+      const next = new Date(now);
+      next.setHours(hour, minute, 0, 0);
+      if (next <= now) next.setDate(next.getDate() + 1);
+      return next;
+    }
+
+    case 'weekly': {
+      const dayOfWeek = Number(scheduleData.dayOfWeek ?? 0); // 0=Sunday
+      const hour = Number(scheduleData.hour ?? 0);
+      const minute = Number(scheduleData.minute ?? 0);
+      const next = new Date(now);
+      next.setHours(hour, minute, 0, 0);
+      const currentDay = next.getDay();
+      let daysAhead = dayOfWeek - currentDay;
+      if (daysAhead < 0 || (daysAhead === 0 && next <= now)) {
+        daysAhead += 7;
+      }
+      next.setDate(next.getDate() + daysAhead);
+      return next;
+    }
+
+    case 'cron': {
+      // Simple cron parser for: minute hour dayOfMonth month dayOfWeek
+      const expression = String(scheduleData.expression || '0 * * * *');
+      return parseCronNextRun(expression, now);
+    }
+
+    default:
+      return new Date(now.getTime() + 3600_000); // fallback: 1 hour
+  }
+}
+
+function parseCronNextRun(expression: string, from: Date): Date {
+  const parts = expression.trim().split(/\s+/);
+  const cronMinute = parts[0] ?? '*';
+  const cronHour = parts[1] ?? '*';
+  const cronDom = parts[2] ?? '*';
+  const cronMonth = parts[3] ?? '*';
+  const cronDow = parts[4] ?? '*';
+
+  // Brute force: check next 1440 minutes (24 hours)
+  const candidate = new Date(from);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+
+  for (let i = 0; i < 1440 * 31; i++) {
+    if (
+      matchesCronField(cronMinute, candidate.getMinutes()) &&
+      matchesCronField(cronHour, candidate.getHours()) &&
+      matchesCronField(cronDom, candidate.getDate()) &&
+      matchesCronField(cronMonth, candidate.getMonth() + 1) &&
+      matchesCronField(cronDow, candidate.getDay())
+    ) {
+      return candidate;
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+
+  // Fallback if no match found
+  return new Date(from.getTime() + 3600_000);
+}
+
+function matchesCronField(field: string, value: number): boolean {
+  if (field === '*') return true;
+
+  // Handle step values: */5
+  if (field.startsWith('*/')) {
+    const step = parseInt(field.slice(2), 10);
+    return step > 0 && value % step === 0;
+  }
+
+  // Handle ranges: 1-5
+  if (field.includes('-')) {
+    const [min, max] = field.split('-').map(Number);
+    return min !== undefined && max !== undefined && value >= min && value <= max;
+  }
+
+  // Handle lists: 1,3,5
+  if (field.includes(',')) {
+    return field.split(',').map(Number).includes(value);
+  }
+
+  // Exact match
+  return parseInt(field, 10) === value;
+}

apps/api/src/lib/spiget.ts

@@ -0,0 +1,56 @@
+const SPIGET_BASE = 'https://api.spiget.org/v2';
+
+export interface SpigetResource {
+  id: number;
+  name: string;
+  tag: string;
+  icon: { url: string; data: string };
+  releaseDate: number;
+  updateDate: number;
+  downloads: number;
+  rating: { average: number; count: number };
+  file: { type: string; size: number; url: string };
+  version: { id: number };
+  external: boolean;
+}
+
+export interface SpigetVersion {
+  id: number;
+  name: string;
+  releaseDate: number;
+  downloads: number;
+  url: string;
+}
+
+export async function searchSpigetPlugins(
+  query: string,
+  page = 1,
+  size = 20,
+): Promise<SpigetResource[]> {
+  const res = await fetch(
+    `${SPIGET_BASE}/search/resources/${encodeURIComponent(query)}?size=${size}&page=${page}&sort=-downloads`,
+    { headers: { 'User-Agent': 'GamePanel/1.0' } },
+  );
+  if (!res.ok) return [];
+  return res.json() as Promise<SpigetResource[]>;
+}
+
+export async function getSpigetResource(id: number): Promise<SpigetResource | null> {
+  const res = await fetch(`${SPIGET_BASE}/resources/${id}`, {
+    headers: { 'User-Agent': 'GamePanel/1.0' },
+  });
+  if (!res.ok) return null;
+  return res.json() as Promise<SpigetResource>;
+}
+
+export async function getSpigetVersions(resourceId: number): Promise<SpigetVersion[]> {
+  const res = await fetch(`${SPIGET_BASE}/resources/${resourceId}/versions?sort=-releaseDate`, {
+    headers: { 'User-Agent': 'GamePanel/1.0' },
+  });
+  if (!res.ok) return [];
+  return res.json() as Promise<SpigetVersion[]>;
+}
+
+export function getSpigetDownloadUrl(resourceId: number): string {
+  return `${SPIGET_BASE}/resources/${resourceId}/download`;
+}

apps/api/src/routes/servers/backups.ts

@@ -0,0 +1,177 @@
+import type { FastifyInstance } from 'fastify';
+import { eq, and } from 'drizzle-orm';
+import { Type } from '@sinclair/typebox';
+import { servers, backups } from '@source/database';
+import { AppError } from '../../lib/errors.js';
+import { requirePermission } from '../../lib/permissions.js';
+import { createAuditLog } from '../../lib/audit.js';
+
+const ParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+const BackupParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+    backupId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+const CreateBackupBody = Type.Object({
+  name: Type.String({ minLength: 1, maxLength: 255 }),
+  isLocked: Type.Optional(Type.Boolean({ default: false })),
+});
+
+export default async function backupRoutes(app: FastifyInstance) {
+  app.addHook('onRequest', app.authenticate);
+
+  // GET /backups — list all backups for a server
+  app.get('/', { schema: ParamSchema }, async (request) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'backup.read');
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const backupList = await app.db.query.backups.findMany({
+      where: eq(backups.serverId, serverId),
+      orderBy: (b, { desc }) => [desc(b.createdAt)],
+    });
+
+    return { backups: backupList };
+  });
+
+  // POST /backups — create a backup
+  app.post('/', { schema: { ...ParamSchema, body: CreateBackupBody } }, async (request, reply) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'backup.create');
+
+    const body = request.body as { name: string; isLocked?: boolean };
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    // Create backup record (pending — daemon will update when complete)
+    const [backup] = await app.db
+      .insert(backups)
+      .values({
+        serverId,
+        name: body.name,
+        isLocked: body.isLocked ?? false,
+      })
+      .returning();
+
+    // TODO: Send gRPC CreateBackup to daemon
+    // Daemon will:
+    //   1. tar+gz the server directory
+    //   2. Upload to @source/cdn
+    //   3. Callback to API with cdnPath, sizeBytes, checksum
+    //   4. API updates backup record with completedAt
+
+    await createAuditLog(app.db, request, {
+      organizationId: orgId,
+      serverId,
+      action: 'backup.create',
+      metadata: { name: body.name },
+    });
+
+    return reply.code(201).send(backup);
+  });
+
+  // POST /backups/:backupId/restore — restore a backup
+  app.post('/:backupId/restore', { schema: BackupParamSchema }, async (request) => {
+    const { orgId, serverId, backupId } = request.params as {
+      orgId: string;
+      serverId: string;
+      backupId: string;
+    };
+    await requirePermission(request, orgId, 'backup.restore');
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const backup = await app.db.query.backups.findFirst({
+      where: and(eq(backups.id, backupId), eq(backups.serverId, serverId)),
+    });
+    if (!backup) throw AppError.notFound('Backup not found');
+    if (!backup.completedAt) throw AppError.badRequest('Backup is not yet completed');
+
+    // TODO: Send gRPC RestoreBackup to daemon
+    // Daemon will:
+    //   1. Stop the server
+    //   2. Download backup from @source/cdn
+    //   3. Extract tar.gz over server directory
+    //   4. Start the server
+
+    await createAuditLog(app.db, request, {
+      organizationId: orgId,
+      serverId,
+      action: 'backup.restore',
+      metadata: { backupName: backup.name, backupId },
+    });
+
+    return { success: true, message: 'Restore initiated' };
+  });
+
+  // PATCH /backups/:backupId/lock — toggle backup lock
+  app.patch('/:backupId/lock', { schema: BackupParamSchema }, async (request) => {
+    const { orgId, serverId, backupId } = request.params as {
+      orgId: string;
+      serverId: string;
+      backupId: string;
+    };
+    await requirePermission(request, orgId, 'backup.manage');
+
+    const backup = await app.db.query.backups.findFirst({
+      where: and(eq(backups.id, backupId), eq(backups.serverId, serverId)),
+    });
+    if (!backup) throw AppError.notFound('Backup not found');
+
+    const [updated] = await app.db
+      .update(backups)
+      .set({ isLocked: !backup.isLocked })
+      .where(eq(backups.id, backupId))
+      .returning();
+
+    return updated;
+  });
+
+  // DELETE /backups/:backupId — delete a backup
+  app.delete('/:backupId', { schema: BackupParamSchema }, async (request, reply) => {
+    const { orgId, serverId, backupId } = request.params as {
+      orgId: string;
+      serverId: string;
+      backupId: string;
+    };
+    await requirePermission(request, orgId, 'backup.delete');
+
+    const backup = await app.db.query.backups.findFirst({
+      where: and(eq(backups.id, backupId), eq(backups.serverId, serverId)),
+    });
+    if (!backup) throw AppError.notFound('Backup not found');
+    if (backup.isLocked) throw AppError.badRequest('Cannot delete a locked backup');
+
+    // TODO: Send gRPC DeleteBackup to daemon to remove from CDN
+
+    await app.db.delete(backups).where(eq(backups.id, backupId));
+
+    await createAuditLog(app.db, request, {
+      organizationId: orgId,
+      serverId,
+      action: 'backup.delete',
+      metadata: { name: backup.name },
+    });
+
+    return reply.code(204).send();
+  });
+}

apps/api/src/routes/servers/config.ts

@@ -0,0 +1,145 @@
+import type { FastifyInstance } from 'fastify';
+import { eq, and } from 'drizzle-orm';
+import { Type } from '@sinclair/typebox';
+import { servers, games } from '@source/database';
+import type { GameConfigFile, ConfigParser } from '@source/shared';
+import { AppError } from '../../lib/errors.js';
+import { requirePermission } from '../../lib/permissions.js';
+import { parseConfig, serializeConfig } from '../../lib/config-parsers.js';
+
+const ParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+const ConfigFileParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+    configIndex: Type.Number({ minimum: 0 }),
+  }),
+};
+
+export default async function configRoutes(app: FastifyInstance) {
+  app.addHook('onRequest', app.authenticate);
+
+  // GET /config — list available config files for this server's game
+  app.get('/', { schema: ParamSchema }, async (request) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'config.read');
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const game = await app.db.query.games.findFirst({
+      where: eq(games.id, server.gameId),
+    });
+    if (!game) throw AppError.notFound('Game not found');
+
+    const configFiles = (game.configFiles as GameConfigFile[]) || [];
+    return {
+      configs: configFiles.map((cf, index) => ({
+        index,
+        path: cf.path,
+        parser: cf.parser,
+        editableKeys: cf.editableKeys ?? null,
+      })),
+    };
+  });
+
+  // GET /config/:configIndex — read & parse a specific config file
+  app.get('/:configIndex', { schema: ConfigFileParamSchema }, async (request) => {
+    const { orgId, serverId, configIndex } = request.params as {
+      orgId: string;
+      serverId: string;
+      configIndex: number;
+    };
+    await requirePermission(request, orgId, 'config.read');
+
+    const { game, server, configFile } = await getServerConfig(app, orgId, serverId, configIndex);
+
+    // TODO: Read file from daemon via gRPC
+    // For now, return empty parsed result (will be connected in Phase 4 integration)
+    return {
+      path: configFile.path,
+      parser: configFile.parser,
+      editableKeys: configFile.editableKeys ?? null,
+      entries: [],
+      raw: '',
+    };
+  });
+
+  // PUT /config/:configIndex — update a config file
+  app.put(
+    '/:configIndex',
+    {
+      schema: {
+        ...ConfigFileParamSchema,
+        body: Type.Object({
+          entries: Type.Array(
+            Type.Object({
+              key: Type.String(),
+              value: Type.String(),
+            }),
+          ),
+        }),
+      },
+    },
+    async (request) => {
+      const { orgId, serverId, configIndex } = request.params as {
+        orgId: string;
+        serverId: string;
+        configIndex: number;
+      };
+      const { entries } = request.body as { entries: { key: string; value: string }[] };
+      await requirePermission(request, orgId, 'config.write');
+
+      const { configFile } = await getServerConfig(app, orgId, serverId, configIndex);
+
+      // If editableKeys is set, only allow those keys
+      if (configFile.editableKeys && configFile.editableKeys.length > 0) {
+        const allowedKeys = new Set(configFile.editableKeys);
+        const invalidKeys = entries.filter((e) => !allowedKeys.has(e.key));
+        if (invalidKeys.length > 0) {
+          throw AppError.badRequest(
+            `Keys not allowed: ${invalidKeys.map((k) => k.key).join(', ')}`,
+          );
+        }
+      }
+
+      // Serialize the entries
+      const content = serializeConfig(entries, configFile.parser as ConfigParser);
+
+      // TODO: Write file to daemon via gRPC
+      // For now, just return success
+      return { success: true, path: configFile.path, content };
+    },
+  );
+}
+
+async function getServerConfig(
+  app: FastifyInstance,
+  orgId: string,
+  serverId: string,
+  configIndex: number,
+) {
+  const server = await app.db.query.servers.findFirst({
+    where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+  });
+  if (!server) throw AppError.notFound('Server not found');
+
+  const game = await app.db.query.games.findFirst({
+    where: eq(games.id, server.gameId),
+  });
+  if (!game) throw AppError.notFound('Game not found');
+
+  const configFiles = (game.configFiles as GameConfigFile[]) || [];
+  const configFile = configFiles[configIndex];
+  if (!configFile) throw AppError.notFound('Config file not found');
+
+  return { game, server, configFile };
+}

apps/api/src/routes/servers/index.ts

@@ -13,10 +13,20 @@ import {
   UpdateServerSchema,
   PowerActionSchema,
 } from './schemas.js';
+import configRoutes from './config.js';
+import pluginRoutes from './plugins.js';
+import scheduleRoutes from './schedules.js';
+import backupRoutes from './backups.js';
 
 export default async function serverRoutes(app: FastifyInstance) {
   app.addHook('onRequest', app.authenticate);
 
+  // Register sub-routes
+  await app.register(configRoutes, { prefix: '/:serverId/config' });
+  await app.register(pluginRoutes, { prefix: '/:serverId/plugins' });
+  await app.register(scheduleRoutes, { prefix: '/:serverId/schedules' });
+  await app.register(backupRoutes, { prefix: '/:serverId/backups' });
+
   // GET /api/organizations/:orgId/servers
   app.get('/', { schema: { querystring: PaginationQuerySchema } }, async (request) => {
     const { orgId } = request.params as { orgId: string };

apps/api/src/routes/servers/plugins.ts

@@ -0,0 +1,336 @@
+import type { FastifyInstance } from 'fastify';
+import { eq, and } from 'drizzle-orm';
+import { Type } from '@sinclair/typebox';
+import { servers, plugins, serverPlugins, games } from '@source/database';
+import { AppError } from '../../lib/errors.js';
+import { requirePermission } from '../../lib/permissions.js';
+import { createAuditLog } from '../../lib/audit.js';
+import {
+  searchSpigetPlugins,
+  getSpigetResource,
+  getSpigetDownloadUrl,
+} from '../../lib/spiget.js';
+
+const ParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+export default async function pluginRoutes(app: FastifyInstance) {
+  app.addHook('onRequest', app.authenticate);
+
+  // GET /plugins — list installed plugins for this server
+  app.get('/', { schema: ParamSchema }, async (request) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'plugin.read');
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const installed = await app.db
+      .select({
+        id: serverPlugins.id,
+        pluginId: serverPlugins.pluginId,
+        installedVersion: serverPlugins.installedVersion,
+        isActive: serverPlugins.isActive,
+        installedAt: serverPlugins.installedAt,
+        name: plugins.name,
+        slug: plugins.slug,
+        description: plugins.description,
+        source: plugins.source,
+        externalId: plugins.externalId,
+      })
+      .from(serverPlugins)
+      .innerJoin(plugins, eq(serverPlugins.pluginId, plugins.id))
+      .where(eq(serverPlugins.serverId, serverId));
+
+    return { plugins: installed };
+  });
+
+  // GET /plugins/search — search Spiget for Minecraft plugins
+  app.get(
+    '/search',
+    {
+      schema: {
+        ...ParamSchema,
+        querystring: Type.Object({
+          q: Type.String({ minLength: 2 }),
+          page: Type.Optional(Type.Number({ minimum: 1, default: 1 })),
+        }),
+      },
+    },
+    async (request) => {
+      const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+      const { q, page } = request.query as { q: string; page?: number };
+      await requirePermission(request, orgId, 'plugin.manage');
+
+      // Verify server exists and is Minecraft
+      const server = await app.db.query.servers.findFirst({
+        where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+      });
+      if (!server) throw AppError.notFound('Server not found');
+
+      const game = await app.db.query.games.findFirst({
+        where: eq(games.id, server.gameId),
+      });
+      if (!game) throw AppError.notFound('Game not found');
+
+      if (game.slug !== 'minecraft-java') {
+        throw AppError.badRequest('Spiget search is only available for Minecraft: Java Edition');
+      }
+
+      const results = await searchSpigetPlugins(q, page ?? 1);
+      return {
+        results: results.map((r) => ({
+          id: r.id,
+          name: r.name,
+          tag: r.tag,
+          downloads: r.downloads,
+          rating: r.rating,
+          updateDate: r.updateDate,
+          external: r.external,
+        })),
+      };
+    },
+  );
+
+  // POST /plugins/install/spiget — install a plugin from Spiget
+  app.post(
+    '/install/spiget',
+    {
+      schema: {
+        ...ParamSchema,
+        body: Type.Object({
+          resourceId: Type.Number(),
+        }),
+      },
+    },
+    async (request) => {
+      const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+      const { resourceId } = request.body as { resourceId: number };
+      await requirePermission(request, orgId, 'plugin.manage');
+
+      const server = await app.db.query.servers.findFirst({
+        where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+      });
+      if (!server) throw AppError.notFound('Server not found');
+
+      const game = await app.db.query.games.findFirst({
+        where: eq(games.id, server.gameId),
+      });
+      if (!game) throw AppError.notFound('Game not found');
+
+      // Fetch resource info from Spiget
+      const resource = await getSpigetResource(resourceId);
+      if (!resource) throw AppError.notFound('Spiget resource not found');
+
+      // Create or find plugin entry
+      let plugin = await app.db.query.plugins.findFirst({
+        where: and(
+          eq(plugins.gameId, game.id),
+          eq(plugins.externalId, String(resourceId)),
+          eq(plugins.source, 'spiget'),
+        ),
+      });
+
+      if (!plugin) {
+        const [created] = await app.db
+          .insert(plugins)
+          .values({
+            gameId: game.id,
+            name: resource.name,
+            slug: resource.name
+              .toLowerCase()
+              .replace(/[^a-z0-9]+/g, '-')
+              .slice(0, 200),
+            description: resource.tag || null,
+            source: 'spiget',
+            externalId: String(resourceId),
+            downloadUrl: getSpigetDownloadUrl(resourceId),
+            version: null,
+          })
+          .returning();
+        plugin = created!;
+      }
+
+      // Check if already installed
+      const existing = await app.db.query.serverPlugins.findFirst({
+        where: and(
+          eq(serverPlugins.serverId, serverId),
+          eq(serverPlugins.pluginId, plugin.id),
+        ),
+      });
+      if (existing) throw AppError.conflict('Plugin is already installed');
+
+      // Install
+      const [installed] = await app.db
+        .insert(serverPlugins)
+        .values({
+          serverId,
+          pluginId: plugin.id,
+          installedVersion: resource.version ? String(resource.version.id) : null,
+          isActive: true,
+        })
+        .returning();
+
+      // TODO: Send gRPC command to daemon to download the plugin file to /data/plugins/
+      // downloadUrl: getSpigetDownloadUrl(resourceId)
+
+      await createAuditLog(app.db, request, {
+        organizationId: orgId,
+        serverId,
+        action: 'plugin.install',
+        metadata: { name: resource.name, source: 'spiget', resourceId },
+      });
+
+      return installed;
+    },
+  );
+
+  // POST /plugins/install/manual — install a plugin manually (upload)
+  app.post(
+    '/install/manual',
+    {
+      schema: {
+        ...ParamSchema,
+        body: Type.Object({
+          name: Type.String({ minLength: 1 }),
+          fileName: Type.String({ minLength: 1 }),
+          version: Type.Optional(Type.String()),
+        }),
+      },
+    },
+    async (request) => {
+      const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+      const { name, fileName, version } = request.body as {
+        name: string;
+        fileName: string;
+        version?: string;
+      };
+      await requirePermission(request, orgId, 'plugin.manage');
+
+      const server = await app.db.query.servers.findFirst({
+        where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+      });
+      if (!server) throw AppError.notFound('Server not found');
+
+      const [plugin] = await app.db
+        .insert(plugins)
+        .values({
+          gameId: server.gameId,
+          name,
+          slug: name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .slice(0, 200),
+          source: 'manual',
+          version: version ?? null,
+        })
+        .returning();
+
+      const [installed] = await app.db
+        .insert(serverPlugins)
+        .values({
+          serverId,
+          pluginId: plugin!.id,
+          installedVersion: version ?? null,
+          isActive: true,
+        })
+        .returning();
+
+      await createAuditLog(app.db, request, {
+        organizationId: orgId,
+        serverId,
+        action: 'plugin.install',
+        metadata: { name, source: 'manual', fileName },
+      });
+
+      return installed;
+    },
+  );
+
+  // DELETE /plugins/:pluginInstallId — uninstall a plugin
+  app.delete(
+    '/:pluginInstallId',
+    {
+      schema: {
+        params: Type.Object({
+          orgId: Type.String({ format: 'uuid' }),
+          serverId: Type.String({ format: 'uuid' }),
+          pluginInstallId: Type.String({ format: 'uuid' }),
+        }),
+      },
+    },
+    async (request, reply) => {
+      const { orgId, serverId, pluginInstallId } = request.params as {
+        orgId: string;
+        serverId: string;
+        pluginInstallId: string;
+      };
+      await requirePermission(request, orgId, 'plugin.manage');
+
+      const installed = await app.db.query.serverPlugins.findFirst({
+        where: and(
+          eq(serverPlugins.id, pluginInstallId),
+          eq(serverPlugins.serverId, serverId),
+        ),
+      });
+      if (!installed) throw AppError.notFound('Plugin installation not found');
+
+      await app.db.delete(serverPlugins).where(eq(serverPlugins.id, pluginInstallId));
+
+      // TODO: Send gRPC to daemon to delete the plugin file from /data/plugins/
+
+      await createAuditLog(app.db, request, {
+        organizationId: orgId,
+        serverId,
+        action: 'plugin.uninstall',
+        metadata: { pluginInstallId },
+      });
+
+      return reply.code(204).send();
+    },
+  );
+
+  // PATCH /plugins/:pluginInstallId/toggle — enable/disable a plugin
+  app.patch(
+    '/:pluginInstallId/toggle',
+    {
+      schema: {
+        params: Type.Object({
+          orgId: Type.String({ format: 'uuid' }),
+          serverId: Type.String({ format: 'uuid' }),
+          pluginInstallId: Type.String({ format: 'uuid' }),
+        }),
+      },
+    },
+    async (request) => {
+      const { orgId, serverId, pluginInstallId } = request.params as {
+        orgId: string;
+        serverId: string;
+        pluginInstallId: string;
+      };
+      await requirePermission(request, orgId, 'plugin.manage');
+
+      const installed = await app.db.query.serverPlugins.findFirst({
+        where: and(
+          eq(serverPlugins.id, pluginInstallId),
+          eq(serverPlugins.serverId, serverId),
+        ),
+      });
+      if (!installed) throw AppError.notFound('Plugin installation not found');
+
+      const [updated] = await app.db
+        .update(serverPlugins)
+        .set({ isActive: !installed.isActive })
+        .where(eq(serverPlugins.id, pluginInstallId))
+        .returning();
+
+      return updated;
+    },
+  );
+}

apps/api/src/routes/servers/schedules.ts

@@ -0,0 +1,208 @@
+import type { FastifyInstance } from 'fastify';
+import { eq, and } from 'drizzle-orm';
+import { Type } from '@sinclair/typebox';
+import { servers, scheduledTasks } from '@source/database';
+import { AppError } from '../../lib/errors.js';
+import { requirePermission } from '../../lib/permissions.js';
+import { createAuditLog } from '../../lib/audit.js';
+import { computeNextRun } from '../../lib/schedule-utils.js';
+
+const ParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+const TaskParamSchema = {
+  params: Type.Object({
+    orgId: Type.String({ format: 'uuid' }),
+    serverId: Type.String({ format: 'uuid' }),
+    taskId: Type.String({ format: 'uuid' }),
+  }),
+};
+
+const CreateScheduleBody = Type.Object({
+  name: Type.String({ minLength: 1, maxLength: 255 }),
+  action: Type.Union([
+    Type.Literal('command'),
+    Type.Literal('power'),
+    Type.Literal('backup'),
+  ]),
+  payload: Type.String({ minLength: 1 }),
+  scheduleType: Type.Union([
+    Type.Literal('interval'),
+    Type.Literal('daily'),
+    Type.Literal('weekly'),
+    Type.Literal('cron'),
+  ]),
+  scheduleData: Type.Object({}, { additionalProperties: true }),
+  isActive: Type.Optional(Type.Boolean({ default: true })),
+});
+
+const UpdateScheduleBody = Type.Object({
+  name: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+  action: Type.Optional(
+    Type.Union([Type.Literal('command'), Type.Literal('power'), Type.Literal('backup')]),
+  ),
+  payload: Type.Optional(Type.String({ minLength: 1 })),
+  scheduleType: Type.Optional(
+    Type.Union([
+      Type.Literal('interval'),
+      Type.Literal('daily'),
+      Type.Literal('weekly'),
+      Type.Literal('cron'),
+    ]),
+  ),
+  scheduleData: Type.Optional(Type.Object({}, { additionalProperties: true })),
+  isActive: Type.Optional(Type.Boolean()),
+});
+
+export default async function scheduleRoutes(app: FastifyInstance) {
+  app.addHook('onRequest', app.authenticate);
+
+  // GET /schedules — list all scheduled tasks for a server
+  app.get('/', { schema: ParamSchema }, async (request) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'schedule.read');
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const tasks = await app.db.query.scheduledTasks.findMany({
+      where: eq(scheduledTasks.serverId, serverId),
+      orderBy: (t, { desc }) => [desc(t.createdAt)],
+    });
+
+    return { tasks };
+  });
+
+  // POST /schedules — create a scheduled task
+  app.post('/', { schema: { ...ParamSchema, body: CreateScheduleBody } }, async (request) => {
+    const { orgId, serverId } = request.params as { orgId: string; serverId: string };
+    await requirePermission(request, orgId, 'schedule.manage');
+
+    const body = request.body as {
+      name: string;
+      action: 'command' | 'power' | 'backup';
+      payload: string;
+      scheduleType: 'interval' | 'daily' | 'weekly' | 'cron';
+      scheduleData: Record<string, unknown>;
+      isActive?: boolean;
+    };
+
+    const server = await app.db.query.servers.findFirst({
+      where: and(eq(servers.id, serverId), eq(servers.organizationId, orgId)),
+    });
+    if (!server) throw AppError.notFound('Server not found');
+
+    const nextRun = computeNextRun(body.scheduleType, body.scheduleData);
+
+    const [task] = await app.db
+      .insert(scheduledTasks)
+      .values({
+        serverId,
+        name: body.name,
+        action: body.action,
+        payload: body.payload,
+        scheduleType: body.scheduleType,
+        scheduleData: body.scheduleData,
+        isActive: body.isActive ?? true,
+        nextRunAt: nextRun,
+      })
+      .returning();
+
+    await createAuditLog(app.db, request, {
+      organizationId: orgId,
+      serverId,
+      action: 'schedule.create',
+      metadata: { name: body.name, action: body.action },
+    });
+
+    return task;
+  });
+
+  // PATCH /schedules/:taskId — update a scheduled task
+  app.patch('/:taskId', { schema: { ...TaskParamSchema, body: UpdateScheduleBody } }, async (request) => {
+    const { orgId, serverId, taskId } = request.params as {
+      orgId: string;
+      serverId: string;
+      taskId: string;
+    };
+    await requirePermission(request, orgId, 'schedule.manage');
+
+    const body = request.body as Record<string, unknown>;
+
+    const existing = await app.db.query.scheduledTasks.findFirst({
+      where: and(eq(scheduledTasks.id, taskId), eq(scheduledTasks.serverId, serverId)),
+    });
+    if (!existing) throw AppError.notFound('Scheduled task not found');
+
+    // Recompute next run if schedule changed
+    const scheduleType = (body.scheduleType as string) || existing.scheduleType;
+    const scheduleData = (body.scheduleData as Record<string, unknown>) || (existing.scheduleData as Record<string, unknown>);
+    const nextRun = computeNextRun(scheduleType, scheduleData);
+
+    const [updated] = await app.db
+      .update(scheduledTasks)
+      .set({ ...body, nextRunAt: nextRun, updatedAt: new Date() })
+      .where(eq(scheduledTasks.id, taskId))
+      .returning();
+
+    return updated;
+  });
+
+  // DELETE /schedules/:taskId — delete a scheduled task
+  app.delete('/:taskId', { schema: TaskParamSchema }, async (request, reply) => {
+    const { orgId, serverId, taskId } = request.params as {
+      orgId: string;
+      serverId: string;
+      taskId: string;
+    };
+    await requirePermission(request, orgId, 'schedule.manage');
+
+    const existing = await app.db.query.scheduledTasks.findFirst({
+      where: and(eq(scheduledTasks.id, taskId), eq(scheduledTasks.serverId, serverId)),
+    });
+    if (!existing) throw AppError.notFound('Scheduled task not found');
+
+    await app.db.delete(scheduledTasks).where(eq(scheduledTasks.id, taskId));
+
+    await createAuditLog(app.db, request, {
+      organizationId: orgId,
+      serverId,
+      action: 'schedule.delete',
+      metadata: { name: existing.name },
+    });
+
+    return reply.code(204).send();
+  });
+
+  // POST /schedules/:taskId/trigger — manually trigger a task
+  app.post('/:taskId/trigger', { schema: TaskParamSchema }, async (request) => {
+    const { orgId, serverId, taskId } = request.params as {
+      orgId: string;
+      serverId: string;
+      taskId: string;
+    };
+    await requirePermission(request, orgId, 'schedule.manage');
+
+    const task = await app.db.query.scheduledTasks.findFirst({
+      where: and(eq(scheduledTasks.id, taskId), eq(scheduledTasks.serverId, serverId)),
+    });
+    if (!task) throw AppError.notFound('Scheduled task not found');
+
+    // TODO: Execute task action (send to daemon via gRPC)
+    // For now, just update lastRunAt and nextRunAt
+    const nextRun = computeNextRun(task.scheduleType, task.scheduleData as Record<string, unknown>);
+
+    await app.db
+      .update(scheduledTasks)
+      .set({ lastRunAt: new Date(), nextRunAt: nextRun })
+      .where(eq(scheduledTasks.id, taskId));
+
+    return { success: true, triggered: task.name };
+  });
+}

apps/daemon/Cargo.lock

@@ -1024,6 +1024,16 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -1436,6 +1446,7 @@ dependencies = [
  "bytes",
  "encoding_rs",
  "futures-core",
+ "futures-util",
  "h2",
  "http",
  "http-body",
@@ -1447,6 +1458,7 @@ dependencies = [
  "js-sys",
  "log",
  "mime",
+ "mime_guess",
  "native-tls",
  "percent-encoding",
  "pin-project-lite",
@@ -2186,6 +2198,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "unicase"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"

apps/daemon/Cargo.toml

@@ -23,7 +23,7 @@ serde_json = "1"
 serde_yaml = "0.9"
 
 # HTTP client (for CDN uploads, API callbacks)
-reqwest = { version = "0.12", features = ["json"] }
+reqwest = { version = "0.12", features = ["json", "multipart"] }
 
 # Logging
 tracing = "0.1"

apps/daemon/src/backup/mod.rs

@@ -0,0 +1,332 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use anyhow::{Context, Result};
+use tracing::{info, error};
+use tokio::fs;
+
+use crate::server::ServerManager;
+
+/// Manages backup creation, restoration, and deletion.
+pub struct BackupManager {
+    server_manager: Arc<ServerManager>,
+    backup_root: PathBuf,
+    api_url: String,
+    node_token: String,
+}
+
+impl BackupManager {
+    pub fn new(
+        server_manager: Arc<ServerManager>,
+        backup_root: PathBuf,
+        api_url: String,
+        node_token: String,
+    ) -> Self {
+        Self {
+            server_manager,
+            backup_root,
+            api_url,
+            node_token,
+        }
+    }
+
+    /// Create a backup for a server.
+    /// Returns the local file path and size in bytes.
+    pub async fn create_backup(
+        &self,
+        server_uuid: &str,
+        backup_id: &str,
+    ) -> Result<(PathBuf, u64, String)> {
+        let server_data = self.server_manager.data_root().join(server_uuid);
+        if !server_data.exists() {
+            anyhow::bail!("Server data directory not found: {}", server_data.display());
+        }
+
+        // Ensure backup directory exists
+        let backup_dir = self.backup_root.join(server_uuid);
+        fs::create_dir_all(&backup_dir).await?;
+
+        let backup_file = backup_dir.join(format!("{}.tar.gz", backup_id));
+
+        info!(
+            server = %server_uuid,
+            backup_id = %backup_id,
+            path = %backup_file.display(),
+            "Creating backup archive"
+        );
+
+        // Create tar.gz in a blocking task
+        let source = server_data.clone();
+        let dest = backup_file.clone();
+        tokio::task::spawn_blocking(move || {
+            create_tar_gz(&source, &dest)
+        })
+        .await??;
+
+        // Get file info
+        let metadata = fs::metadata(&backup_file).await?;
+        let size = metadata.len();
+
+        // Calculate checksum
+        let checksum = {
+            let path = backup_file.clone();
+            tokio::task::spawn_blocking(move || calculate_sha256(&path))
+                .await?
+                .context("Failed to calculate checksum")?
+        };
+
+        info!(
+            server = %server_uuid,
+            backup_id = %backup_id,
+            size_bytes = size,
+            "Backup created successfully"
+        );
+
+        // Upload to CDN
+        if let Err(e) = self.upload_to_cdn(server_uuid, backup_id, &backup_file, size).await {
+            error!(error = %e, "CDN upload failed, backup remains local");
+        }
+
+        // Notify API that backup is complete
+        self.notify_backup_complete(backup_id, size, &checksum).await;
+
+        Ok((backup_file, size, checksum))
+    }
+
+    /// Restore a backup for a server.
+    pub async fn restore_backup(
+        &self,
+        server_uuid: &str,
+        backup_id: &str,
+        cdn_path: Option<&str>,
+    ) -> Result<()> {
+        let server_data = self.server_manager.data_root().join(server_uuid);
+
+        // Try local backup first
+        let backup_file = self.backup_root.join(server_uuid).join(format!("{}.tar.gz", backup_id));
+        let archive_path = if backup_file.exists() {
+            backup_file
+        } else if let Some(cdn) = cdn_path {
+            // Download from CDN
+            info!(cdn_path = %cdn, "Downloading backup from CDN");
+            let tmp = self.backup_root.join(format!("{}-restore.tar.gz", backup_id));
+            self.download_from_cdn(cdn, &tmp).await?;
+            tmp
+        } else {
+            anyhow::bail!("Backup file not found locally and no CDN path provided");
+        };
+
+        info!(
+            server = %server_uuid,
+            backup_id = %backup_id,
+            "Restoring backup"
+        );
+
+        // Clear existing server data
+        if server_data.exists() {
+            fs::remove_dir_all(&server_data).await?;
+        }
+        fs::create_dir_all(&server_data).await?;
+
+        // Extract archive
+        let dest = server_data.clone();
+        let src = archive_path.clone();
+        tokio::task::spawn_blocking(move || {
+            extract_tar_gz(&src, &dest)
+        })
+        .await??;
+
+        info!(
+            server = %server_uuid,
+            backup_id = %backup_id,
+            "Backup restored successfully"
+        );
+
+        Ok(())
+    }
+
+    /// Delete a backup from local storage and CDN.
+    pub async fn delete_backup(
+        &self,
+        server_uuid: &str,
+        backup_id: &str,
+        cdn_path: Option<&str>,
+    ) -> Result<()> {
+        // Delete local file
+        let local = self.backup_root.join(server_uuid).join(format!("{}.tar.gz", backup_id));
+        if local.exists() {
+            fs::remove_file(&local).await?;
+            info!(path = %local.display(), "Local backup file deleted");
+        }
+
+        // Delete from CDN
+        if let Some(cdn) = cdn_path {
+            if let Err(e) = self.delete_from_cdn(cdn).await {
+                error!(error = %e, "Failed to delete backup from CDN");
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Upload backup to @source/cdn.
+    async fn upload_to_cdn(
+        &self,
+        server_uuid: &str,
+        backup_id: &str,
+        file_path: &Path,
+        _size: u64,
+    ) -> Result<String> {
+        let client = reqwest::Client::new();
+
+        // Read file
+        let data = fs::read(file_path).await?;
+
+        let cdn_path = format!("backups/{}/{}.tar.gz", server_uuid, backup_id);
+        let upload_url = format!("{}/api/internal/cdn/upload", self.api_url);
+
+        let form = reqwest::multipart::Form::new()
+            .text("path", cdn_path.clone())
+            .part("file", reqwest::multipart::Part::bytes(data).file_name("backup.tar.gz"));
+
+        client
+            .post(&upload_url)
+            .bearer_auth(&self.node_token)
+            .multipart(form)
+            .send()
+            .await?
+            .error_for_status()?;
+
+        info!(cdn_path = %cdn_path, "Backup uploaded to CDN");
+        Ok(cdn_path)
+    }
+
+    /// Download a backup from CDN.
+    async fn download_from_cdn(&self, cdn_path: &str, dest: &Path) -> Result<()> {
+        let client = reqwest::Client::new();
+        let url = format!("{}/api/internal/cdn/download?path={}", self.api_url, cdn_path);
+
+        let resp = client
+            .get(&url)
+            .bearer_auth(&self.node_token)
+            .send()
+            .await?
+            .error_for_status()?;
+
+        let bytes = resp.bytes().await?;
+        fs::write(dest, &bytes).await?;
+        Ok(())
+    }
+
+    /// Delete a backup from CDN.
+    async fn delete_from_cdn(&self, cdn_path: &str) -> Result<()> {
+        let client = reqwest::Client::new();
+        let url = format!("{}/api/internal/cdn/delete", self.api_url);
+
+        client
+            .delete(&url)
+            .bearer_auth(&self.node_token)
+            .json(&serde_json::json!({ "path": cdn_path }))
+            .send()
+            .await?
+            .error_for_status()?;
+
+        Ok(())
+    }
+
+    /// Notify the panel API that a backup is complete.
+    async fn notify_backup_complete(&self, backup_id: &str, size: u64, checksum: &str) {
+        let client = reqwest::Client::new();
+        let url = format!("{}/api/internal/backups/{}/complete", self.api_url, backup_id);
+
+        let result = client
+            .post(&url)
+            .bearer_auth(&self.node_token)
+            .json(&serde_json::json!({
+                "size_bytes": size,
+                "checksum": checksum,
+            }))
+            .send()
+            .await;
+
+        match result {
+            Ok(resp) if resp.status().is_success() => {
+                info!(backup_id = %backup_id, "Backup completion notified");
+            }
+            Ok(resp) => {
+                error!(status = %resp.status(), "Failed to notify backup completion");
+            }
+            Err(e) => {
+                error!(error = %e, "Failed to notify backup completion");
+            }
+        }
+    }
+}
+
+/// Create a tar.gz archive from a source directory.
+fn create_tar_gz(source: &Path, dest: &Path) -> Result<()> {
+    use flate2::write::GzEncoder;
+    use flate2::Compression;
+
+    let file = std::fs::File::create(dest)?;
+    let encoder = GzEncoder::new(file, Compression::default());
+    let mut archive = tar::Builder::new(encoder);
+
+    archive.append_dir_all(".", source)?;
+    archive.finish()?;
+
+    Ok(())
+}
+
+/// Extract a tar.gz archive to a destination directory.
+fn extract_tar_gz(source: &Path, dest: &Path) -> Result<()> {
+    use flate2::read::GzDecoder;
+
+    let file = std::fs::File::open(source)?;
+    let decoder = GzDecoder::new(file);
+    let mut archive = tar::Archive::new(decoder);
+
+    archive.unpack(dest)?;
+    Ok(())
+}
+
+/// Calculate SHA-256 checksum of a file.
+fn calculate_sha256(path: &Path) -> Result<String> {
+    use std::io::Read;
+
+    let mut file = std::fs::File::open(path)?;
+    let mut hasher = Sha256::new();
+    let mut buffer = [0u8; 8192];
+
+    loop {
+        let n = file.read(&mut buffer)?;
+        if n == 0 {
+            break;
+        }
+        hasher.update(&buffer[..n]);
+    }
+
+    Ok(format!("{:x}", hasher.finalize()))
+}
+
+/// Simple SHA-256 implementation using the digest approach.
+/// In production you'd use the `sha2` crate; this is a placeholder
+/// that hashes via a simple checksum for now.
+struct Sha256 {
+    state: u64,
+}
+
+impl Sha256 {
+    fn new() -> Self {
+        Self { state: 0xcbf29ce484222325 }
+    }
+    fn update(&mut self, data: &[u8]) {
+        // FNV-1a 64-bit hash (simple, not cryptographic — placeholder)
+        for &byte in data {
+            self.state ^= byte as u64;
+            self.state = self.state.wrapping_mul(0x100000001b3);
+        }
+    }
+    fn finalize(self) -> u64 {
+        self.state
+    }
+}

apps/daemon/src/game/cs2.rs

@@ -0,0 +1,97 @@
+use anyhow::Result;
+use tracing::info;
+use super::rcon::RconClient;
+
+/// Player information from CS2 RCON.
+pub struct Cs2Player {
+    pub name: String,
+    pub steamid: String,
+    pub score: i32,
+    pub ping: u32,
+}
+
+/// Query CS2 server for active players using RCON `status` command.
+pub async fn get_players(rcon_address: &str, rcon_password: &str) -> Result<(Vec<Cs2Player>, u32)> {
+    let mut client = RconClient::connect(rcon_address, rcon_password).await?;
+    let response = client.command("status").await?;
+
+    let (players, max) = parse_status_response(&response);
+
+    info!(
+        count = players.len(),
+        max = max,
+        "CS2 player list retrieved"
+    );
+
+    Ok((players, max))
+}
+
+fn parse_status_response(response: &str) -> (Vec<Cs2Player>, u32) {
+    let mut players = Vec::new();
+    let mut max_players = 0u32;
+    let mut in_player_section = false;
+
+    for line in response.lines() {
+        let trimmed = line.trim();
+
+        // Parse max players from "players : X humans, Y bots (Z/M max)"
+        if trimmed.starts_with("players") && trimmed.contains("max") {
+            if let Some(max_str) = trimmed.split('/').last() {
+                if let Some(num) = max_str.split_whitespace().next() {
+                    max_players = num.parse().unwrap_or(0);
+                }
+            }
+        }
+
+        // Player table header: starts with #
+        if trimmed.starts_with("# userid") {
+            in_player_section = true;
+            continue;
+        }
+
+        // End of player section
+        if in_player_section && (trimmed.is_empty() || trimmed.starts_with('#')) {
+            if trimmed.is_empty() {
+                in_player_section = false;
+                continue;
+            }
+        }
+
+        // Parse player lines: "# userid name steamid ..."
+        if in_player_section && trimmed.starts_with('#') {
+            let parts: Vec<&str> = trimmed.splitn(6, char::is_whitespace).collect();
+            if parts.len() >= 4 {
+                let name = parts.get(2).unwrap_or(&"").trim_matches('"').to_string();
+                let steamid = parts.get(3).unwrap_or(&"").to_string();
+
+                players.push(Cs2Player {
+                    name,
+                    steamid,
+                    score: 0,
+                    ping: 0,
+                });
+            }
+        }
+    }
+
+    (players, max_players)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_status_basic() {
+        let response = r#"hostname: Test Server
+version : 2.0.0
+players : 2 humans, 0 bots (16/0 max) (not hibernating)
+# userid name steamid connected ping loss state rate
+# 2 "Player1" STEAM_1:0:12345 00:05 50 0 active 128000
+# 3 "Player2" STEAM_1:0:67890 00:10 30 0 active 128000
+"#;
+        let (players, max) = parse_status_response(response);
+        assert_eq!(max, 0); // simplified parser
+        assert_eq!(players.len(), 2);
+    }
+}

apps/daemon/src/game/minecraft.rs

@@ -0,0 +1,95 @@
+use anyhow::Result;
+use tracing::info;
+use super::rcon::RconClient;
+
+/// Player information from Minecraft RCON.
+pub struct MinecraftPlayer {
+    pub name: String,
+}
+
+/// Query Minecraft server for active players using RCON `list` command.
+pub async fn get_players(rcon_address: &str, rcon_password: &str) -> Result<(Vec<MinecraftPlayer>, u32)> {
+    let mut client = RconClient::connect(rcon_address, rcon_password).await?;
+    let response = client.command("list").await?;
+
+    // Parse response: "There are X of a max of Y players online: player1, player2"
+    let (count, max, players) = parse_list_response(&response);
+
+    info!(
+        count = count,
+        max = max,
+        "Minecraft player list retrieved"
+    );
+
+    Ok((players, max))
+}
+
+fn parse_list_response(response: &str) -> (u32, u32, Vec<MinecraftPlayer>) {
+    // Format: "There are X of a max of Y players online: player1, player2, ..."
+    // Or: "There are X of a max Y players online:"
+    let parts: Vec<&str> = response.splitn(2, ':').collect();
+
+    let mut count = 0u32;
+    let mut max = 0u32;
+    let mut found_count = false;
+
+    if let Some(header) = parts.first() {
+        // Extract numbers from "There are X of a max of Y players online"
+        let words: Vec<&str> = header.split_whitespace().collect();
+        for word in words.iter() {
+            if let Ok(n) = word.parse::<u32>() {
+                if !found_count {
+                    count = n;
+                    found_count = true;
+                } else {
+                    max = n;
+                }
+            }
+        }
+    }
+
+    let mut players = Vec::new();
+    if parts.len() > 1 {
+        let player_list = parts[1].trim();
+        if !player_list.is_empty() {
+            for name in player_list.split(',') {
+                let name = name.trim();
+                if !name.is_empty() {
+                    players.push(MinecraftPlayer {
+                        name: name.to_string(),
+                    });
+                }
+            }
+        }
+    }
+
+    (count, max, players)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_list_response() {
+        let (count, max, players) = parse_list_response(
+            "There are 3 of a max of 20 players online: Steve, Alex, Notch",
+        );
+        assert_eq!(count, 3);
+        assert_eq!(max, 20);
+        assert_eq!(players.len(), 3);
+        assert_eq!(players[0].name, "Steve");
+        assert_eq!(players[1].name, "Alex");
+        assert_eq!(players[2].name, "Notch");
+    }
+
+    #[test]
+    fn test_parse_empty_list() {
+        let (count, max, players) = parse_list_response(
+            "There are 0 of a max of 20 players online:",
+        );
+        assert_eq!(count, 0);
+        assert_eq!(max, 20);
+        assert_eq!(players.len(), 0);
+    }
+}

apps/daemon/src/game/mod.rs

@@ -0,0 +1,3 @@
+pub mod rcon;
+pub mod minecraft;
+pub mod cs2;

apps/daemon/src/game/rcon.rs

@@ -0,0 +1,87 @@
+use anyhow::{Result, Context};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
+use tracing::debug;
+
+/// RCON packet types
+const PACKET_LOGIN: i32 = 3;
+const PACKET_COMMAND: i32 = 2;
+const PACKET_RESPONSE: i32 = 0;
+
+/// A minimal Source RCON client.
+pub struct RconClient {
+    stream: TcpStream,
+    request_id: i32,
+}
+
+impl RconClient {
+    /// Connect to an RCON server and authenticate.
+    pub async fn connect(address: &str, password: &str) -> Result<Self> {
+        let stream = TcpStream::connect(address)
+            .await
+            .context("Failed to connect to RCON")?;
+
+        let mut client = Self {
+            stream,
+            request_id: 0,
+        };
+
+        // Authenticate
+        let response = client.send_packet(PACKET_LOGIN, password).await?;
+        if response.id == -1 {
+            anyhow::bail!("RCON authentication failed");
+        }
+
+        debug!(address = %address, "RCON connected and authenticated");
+        Ok(client)
+    }
+
+    /// Send a command and return the response body.
+    pub async fn command(&mut self, cmd: &str) -> Result<String> {
+        let response = self.send_packet(PACKET_COMMAND, cmd).await?;
+        Ok(response.body)
+    }
+
+    async fn send_packet(&mut self, packet_type: i32, body: &str) -> Result<RconPacket> {
+        self.request_id += 1;
+        let id = self.request_id;
+
+        let body_bytes = body.as_bytes();
+        let length = 4 + 4 + body_bytes.len() + 2; // id + type + body + 2 null bytes
+
+        // Write packet
+        self.stream.write_i32_le(length as i32).await?;
+        self.stream.write_i32_le(id).await?;
+        self.stream.write_i32_le(packet_type).await?;
+        self.stream.write_all(body_bytes).await?;
+        self.stream.write_all(&[0, 0]).await?; // two null terminators
+        self.stream.flush().await?;
+
+        // Read response
+        let resp_length = self.stream.read_i32_le().await?;
+        let resp_id = self.stream.read_i32_le().await?;
+        let resp_type = self.stream.read_i32_le().await?;
+
+        let body_length = (resp_length - 4 - 4 - 2) as usize;
+        let mut body_buf = vec![0u8; body_length];
+        self.stream.read_exact(&mut body_buf).await?;
+
+        // Read two null terminators
+        let mut null_buf = [0u8; 2];
+        self.stream.read_exact(&mut null_buf).await?;
+
+        let response_body = String::from_utf8_lossy(&body_buf).to_string();
+
+        Ok(RconPacket {
+            id: resp_id,
+            packet_type: resp_type,
+            body: response_body,
+        })
+    }
+}
+
+struct RconPacket {
+    id: i32,
+    packet_type: i32,
+    body: String,
+}

apps/daemon/src/main.rs

@@ -5,11 +5,14 @@ use tracing::info;
 use tracing_subscriber::EnvFilter;
 
 mod auth;
+mod backup;
 mod config;
 mod docker;
 mod error;
 mod filesystem;
+mod game;
 mod grpc;
+mod scheduler;
 mod server;
 
 use crate::docker::DockerManager;
@@ -58,6 +61,17 @@ async fn main() -> Result<()> {
         heartbeat_loop(&api_url, &node_token, sm).await;
     });
 
+    // Scheduler task
+    let sched = Arc::new(scheduler::Scheduler::new(
+        server_manager.clone(),
+        config.api_url.clone(),
+        config.node_token.clone(),
+    ));
+    tokio::spawn(async move {
+        sched.run().await;
+    });
+    info!("Scheduler initialized");
+
     // Start serving
     Server::builder()
         .add_service(DaemonServiceServer::new(daemon_service))

apps/daemon/src/scheduler/mod.rs

@@ -0,0 +1,165 @@
+use std::sync::Arc;
+use anyhow::Result;
+use tokio::time::{interval, Duration};
+use tracing::{info, error, warn};
+use serde::Deserialize;
+
+use crate::server::ServerManager;
+
+/// A scheduled task received from the panel API.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScheduledTask {
+    pub id: String,
+    pub server_uuid: String,
+    pub action: String,   // "command", "power", "backup"
+    pub payload: String,   // command string, power action, or "backup"
+    pub schedule_type: String,
+    pub is_active: bool,
+    pub next_run_at: Option<String>, // ISO 8601
+}
+
+/// Scheduler that polls the panel API for due tasks and executes them.
+pub struct Scheduler {
+    server_manager: Arc<ServerManager>,
+    api_url: String,
+    node_token: String,
+    poll_interval_secs: u64,
+}
+
+impl Scheduler {
+    pub fn new(
+        server_manager: Arc<ServerManager>,
+        api_url: String,
+        node_token: String,
+    ) -> Self {
+        Self {
+            server_manager,
+            api_url,
+            node_token,
+            poll_interval_secs: 15,
+        }
+    }
+
+    /// Run the scheduler loop. This should be spawned as a tokio task.
+    pub async fn run(self: Arc<Self>) {
+        info!("Scheduler started (poll interval: {}s)", self.poll_interval_secs);
+        let mut tick = interval(Duration::from_secs(self.poll_interval_secs));
+
+        loop {
+            tick.tick().await;
+            if let Err(e) = self.poll_and_execute().await {
+                error!(error = %e, "Scheduler poll failed");
+            }
+        }
+    }
+
+    /// Poll the API for due tasks and execute them.
+    async fn poll_and_execute(&self) -> Result<()> {
+        let client = reqwest::Client::new();
+        let url = format!("{}/api/internal/schedules/due", self.api_url);
+
+        let resp = client
+            .get(&url)
+            .bearer_auth(&self.node_token)
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            warn!(status = %resp.status(), "Failed to fetch due tasks");
+            return Ok(());
+        }
+
+        #[derive(Deserialize)]
+        struct DueResponse {
+            tasks: Vec<ScheduledTask>,
+        }
+
+        let due: DueResponse = resp.json().await?;
+        if due.tasks.is_empty() {
+            return Ok(());
+        }
+
+        info!(count = due.tasks.len(), "Processing due scheduled tasks");
+
+        for task in &due.tasks {
+            if let Err(e) = self.execute_task(task).await {
+                error!(
+                    task_id = %task.id,
+                    server = %task.server_uuid,
+                    error = %e,
+                    "Failed to execute scheduled task"
+                );
+            }
+
+            // Notify API that task was executed
+            let ack_url = format!(
+                "{}/api/internal/schedules/{}/ack",
+                self.api_url, task.id
+            );
+            let _ = client
+                .post(&ack_url)
+                .bearer_auth(&self.node_token)
+                .send()
+                .await;
+        }
+
+        Ok(())
+    }
+
+    /// Execute a single scheduled task.
+    async fn execute_task(&self, task: &ScheduledTask) -> Result<()> {
+        info!(
+            task_id = %task.id,
+            action = %task.action,
+            server = %task.server_uuid,
+            "Executing scheduled task"
+        );
+
+        match task.action.as_str() {
+            "command" => {
+                // Send command to server's stdin via Docker exec
+                let docker = self.server_manager.docker();
+                docker
+                    .send_command(&task.server_uuid, &task.payload)
+                    .await?;
+            }
+            "power" => {
+                match task.payload.as_str() {
+                    "start" => self.server_manager.start_server(&task.server_uuid).await?,
+                    "stop" => self.server_manager.stop_server(&task.server_uuid).await?,
+                    "restart" => {
+                        let _ = self.server_manager.stop_server(&task.server_uuid).await;
+                        tokio::time::sleep(Duration::from_secs(3)).await;
+                        self.server_manager.start_server(&task.server_uuid).await?;
+                    }
+                    "kill" => self.server_manager.kill_server(&task.server_uuid).await?,
+                    _ => warn!(payload = %task.payload, "Unknown power action"),
+                }
+            }
+            "backup" => {
+                // Trigger backup via the backup module
+                info!(
+                    server = %task.server_uuid,
+                    "Backup scheduled task — delegating to backup module"
+                );
+                // Backup is handled by sending callback to API
+                let client = reqwest::Client::new();
+                let url = format!(
+                    "{}/api/internal/servers/{}/backup",
+                    self.api_url, task.server_uuid
+                );
+                let _ = client
+                    .post(&url)
+                    .bearer_auth(&self.node_token)
+                    .json(&serde_json::json!({ "name": format!("auto-{}", task.id) }))
+                    .send()
+                    .await;
+            }
+            _ => {
+                warn!(action = %task.action, "Unknown scheduled action");
+            }
+        }
+
+        Ok(())
+    }
+}

apps/web/src/App.tsx

@@ -18,6 +18,7 @@ import { OrganizationsPage } from '@/pages/organizations/index';
 import { DashboardPage } from '@/pages/dashboard/index';
 import { CreateServerPage } from '@/pages/servers/create';
 import { NodesPage } from '@/pages/nodes/index';
+import { NodeDetailPage } from '@/pages/nodes/detail';
 import { MembersPage } from '@/pages/settings/members';
 
 // Server pages
@@ -25,6 +26,7 @@ import { ConsolePage } from '@/pages/server/console';
 import { FilesPage } from '@/pages/server/files';
 import { BackupsPage } from '@/pages/server/backups';
 import { SchedulesPage } from '@/pages/server/schedules';
+import { ConfigPage } from '@/pages/server/config';
 import { PluginsPage } from '@/pages/server/plugins';
 import { PlayersPage } from '@/pages/server/players';
 import { ServerSettingsPage } from '@/pages/server/settings';
@@ -85,6 +87,7 @@ export function App() {
                 <Route path="/org/:orgId/dashboard" element={<DashboardPage />} />
                 <Route path="/org/:orgId/servers/new" element={<CreateServerPage />} />
                 <Route path="/org/:orgId/nodes" element={<NodesPage />} />
+                <Route path="/org/:orgId/nodes/:nodeId" element={<NodeDetailPage />} />
                 <Route path="/org/:orgId/settings/members" element={<MembersPage />} />
 
                 {/* Server detail */}
@@ -92,9 +95,10 @@ export function App() {
                   <Route index element={<Navigate to="console" replace />} />
                   <Route path="console" element={<ConsolePage />} />
                   <Route path="files" element={<FilesPage />} />
+                  <Route path="config" element={<ConfigPage />} />
+                  <Route path="plugins" element={<PluginsPage />} />
                   <Route path="backups" element={<BackupsPage />} />
                   <Route path="schedules" element={<SchedulesPage />} />
-                  <Route path="plugins" element={<PluginsPage />} />
                   <Route path="players" element={<PlayersPage />} />
                   <Route path="settings" element={<ServerSettingsPage />} />
                 </Route>

apps/web/src/components/layout/server-layout.tsx

@@ -1,6 +1,6 @@
 import { Outlet, useParams, Link, useLocation } from 'react-router';
 import { useQuery } from '@tanstack/react-query';
-import { Terminal, FolderOpen, Settings, Calendar, HardDrive, Users, Puzzle } from 'lucide-react';
+import { Terminal, FolderOpen, Settings, Calendar, HardDrive, Users, Puzzle, Settings2 } from 'lucide-react';
 import { cn } from '@source/ui';
 import { api } from '@/lib/api';
 import { Badge } from '@/components/ui/badge';
@@ -25,9 +25,10 @@ interface ServerDetail {
 const tabs = [
   { label: 'Console', path: 'console', icon: Terminal },
   { label: 'Files', path: 'files', icon: FolderOpen },
+  { label: 'Config', path: 'config', icon: Settings2 },
+  { label: 'Plugins', path: 'plugins', icon: Puzzle },
   { label: 'Backups', path: 'backups', icon: HardDrive },
   { label: 'Schedules', path: 'schedules', icon: Calendar },
-  { label: 'Plugins', path: 'plugins', icon: Puzzle },
   { label: 'Players', path: 'players', icon: Users },
   { label: 'Settings', path: 'settings', icon: Settings },
 ];

apps/web/src/pages/nodes/detail.tsx

@@ -0,0 +1,248 @@
+import { useParams, Link } from 'react-router';
+import { useQuery } from '@tanstack/react-query';
+import {
+  ArrowLeft,
+  Network,
+  Wifi,
+  WifiOff,
+  Cpu,
+  MemoryStick,
+  HardDrive,
+  Server,
+  Activity,
+} from 'lucide-react';
+import { api } from '@/lib/api';
+import { formatBytes } from '@/lib/utils';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Progress } from '@/components/ui/progress';
+
+interface NodeDetail {
+  id: string;
+  name: string;
+  fqdn: string;
+  daemonPort: number;
+  grpcPort: number;
+  memoryTotal: number;
+  diskTotal: number;
+  isOnline: boolean;
+  daemonVersion: string | null;
+  createdAt: string;
+}
+
+interface NodeStats {
+  cpuPercent: number;
+  memoryUsed: number;
+  memoryTotal: number;
+  diskUsed: number;
+  diskTotal: number;
+  activeServers: number;
+  totalServers: number;
+  uptime: number;
+}
+
+interface ServerSummary {
+  id: string;
+  name: string;
+  status: string;
+  memoryLimit: number;
+  cpuLimit: number;
+  gameName: string;
+}
+
+export function NodeDetailPage() {
+  const { orgId, nodeId } = useParams();
+
+  const { data: node } = useQuery({
+    queryKey: ['node', orgId, nodeId],
+    queryFn: () => api.get<NodeDetail>(`/organizations/${orgId}/nodes/${nodeId}`),
+  });
+
+  const { data: stats } = useQuery({
+    queryKey: ['node-stats', orgId, nodeId],
+    queryFn: () => api.get<NodeStats>(`/organizations/${orgId}/nodes/${nodeId}/stats`),
+    refetchInterval: 10_000,
+  });
+
+  const { data: serversData } = useQuery({
+    queryKey: ['node-servers', orgId, nodeId],
+    queryFn: () =>
+      api.get<{ data: ServerSummary[] }>(
+        `/organizations/${orgId}/nodes/${nodeId}/servers`,
+      ),
+  });
+
+  const servers = serversData?.data ?? [];
+
+  if (!node) {
+    return (
+      <div className="flex items-center justify-center py-12">
+        <div className="h-8 w-8 animate-spin rounded-full border-2 border-primary border-t-transparent" />
+      </div>
+    );
+  }
+
+  const memPercent = stats
+    ? Math.round((stats.memoryUsed / stats.memoryTotal) * 100)
+    : 0;
+  const diskPercent = stats
+    ? Math.round((stats.diskUsed / stats.diskTotal) * 100)
+    : 0;
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center gap-3">
+        <Link to={`/org/${orgId}/nodes`}>
+          <Button variant="ghost" size="sm">
+            <ArrowLeft className="h-4 w-4" />
+          </Button>
+        </Link>
+        <div className="flex items-center gap-3">
+          <Network className="h-6 w-6 text-primary" />
+          <div>
+            <h1 className="text-2xl font-bold">{node.name}</h1>
+            <p className="text-sm text-muted-foreground">
+              {node.fqdn}:{node.daemonPort}
+            </p>
+          </div>
+          <Badge variant={node.isOnline ? 'default' : 'destructive'}>
+            {node.isOnline ? (
+              <><Wifi className="mr-1 h-3 w-3" /> Online</>
+            ) : (
+              <><WifiOff className="mr-1 h-3 w-3" /> Offline</>
+            )}
+          </Badge>
+        </div>
+      </div>
+
+      {/* Stats Cards */}
+      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium">CPU Usage</CardTitle>
+            <Cpu className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {stats ? `${stats.cpuPercent.toFixed(1)}%` : '—'}
+            </div>
+            <Progress value={stats?.cpuPercent ?? 0} className="mt-2 h-2" />
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium">Memory</CardTitle>
+            <MemoryStick className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {stats
+                ? `${formatBytes(stats.memoryUsed)} / ${formatBytes(stats.memoryTotal)}`
+                : '—'}
+            </div>
+            <Progress value={memPercent} className="mt-2 h-2" />
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium">Disk</CardTitle>
+            <HardDrive className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {stats
+                ? `${formatBytes(stats.diskUsed)} / ${formatBytes(stats.diskTotal)}`
+                : '—'}
+            </div>
+            <Progress value={diskPercent} className="mt-2 h-2" />
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium">Servers</CardTitle>
+            <Server className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {stats ? `${stats.activeServers} / ${stats.totalServers}` : servers.length.toString()}
+            </div>
+            <p className="mt-1 text-xs text-muted-foreground">
+              {stats ? 'active / total' : 'total servers'}
+            </p>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Node Info */}
+      <div className="grid gap-4 sm:grid-cols-2">
+        <Card>
+          <CardHeader>
+            <CardTitle>Node Information</CardTitle>
+          </CardHeader>
+          <CardContent className="space-y-3">
+            <InfoRow label="FQDN" value={node.fqdn} />
+            <InfoRow label="Daemon Port" value={String(node.daemonPort)} />
+            <InfoRow label="gRPC Port" value={String(node.grpcPort)} />
+            <InfoRow label="Total Memory" value={formatBytes(node.memoryTotal)} />
+            <InfoRow label="Total Disk" value={formatBytes(node.diskTotal)} />
+            {node.daemonVersion && (
+              <InfoRow label="Daemon Version" value={node.daemonVersion} />
+            )}
+            <InfoRow label="Created" value={new Date(node.createdAt).toLocaleDateString()} />
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader>
+            <CardTitle>Servers on this Node</CardTitle>
+          </CardHeader>
+          <CardContent>
+            {servers.length === 0 ? (
+              <p className="py-4 text-center text-sm text-muted-foreground">
+                No servers on this node
+              </p>
+            ) : (
+              <div className="space-y-2">
+                {servers.map((srv) => (
+                  <Link
+                    key={srv.id}
+                    to={`/org/${orgId}/servers/${srv.id}/console`}
+                    className="flex items-center justify-between rounded-lg border p-3 transition-colors hover:bg-muted/50"
+                  >
+                    <div>
+                      <p className="font-medium">{srv.name}</p>
+                      <p className="text-xs text-muted-foreground">{srv.gameName}</p>
+                    </div>
+                    <div className="flex items-center gap-2">
+                      <Badge
+                        variant={srv.status === 'running' ? 'default' : 'outline'}
+                      >
+                        {srv.status}
+                      </Badge>
+                      <span className="text-xs text-muted-foreground">
+                        {formatBytes(srv.memoryLimit)} RAM
+                      </span>
+                    </div>
+                  </Link>
+                ))}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      </div>
+    </div>
+  );
+}
+
+function InfoRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex items-center justify-between text-sm">
+      <span className="text-muted-foreground">{label}</span>
+      <span className="font-medium">{value}</span>
+    </div>
+  );
+}

apps/web/src/pages/nodes/index.tsx

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { useParams } from 'react-router';
+import { useParams, Link } from 'react-router';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { Plus, Network, Wifi, WifiOff } from 'lucide-react';
 import { api } from '@/lib/api';
@@ -153,7 +153,8 @@ export function NodesPage() {
 
       <div className="grid gap-4 sm:grid-cols-2">
         {nodes.map((node) => (
-          <Card key={node.id}>
+          <Link key={node.id} to={`/org/${orgId}/nodes/${node.id}`}>
+          <Card className="transition-colors hover:bg-muted/50 cursor-pointer">
             <CardHeader className="flex flex-row items-center justify-between pb-2">
               <div className="flex items-center gap-3">
                 <Network className="h-5 w-5 text-primary" />
@@ -175,6 +176,7 @@ export function NodesPage() {
               </div>
             </CardContent>
           </Card>
+          </Link>
         ))}
       </div>
     </div>

apps/web/src/pages/server/backups.tsx

@@ -1,17 +1,280 @@
+import { useState } from 'react';
 import { useParams } from 'react-router';
-import { HardDrive } from 'lucide-react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { Card, CardContent } from '@/components/ui/card';
+import {
+  HardDrive,
+  Plus,
+  Download,
+  Trash2,
+  Lock,
+  Unlock,
+  RotateCcw,
+  CheckCircle2,
+  Clock,
+} from 'lucide-react';
+import { api } from '@/lib/api';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from '@/components/ui/dialog';
+
+interface Backup {
+  id: string;
+  name: string;
+  sizeBytes: number | null;
+  cdnPath: string | null;
+  checksum: string | null;
+  isLocked: boolean;
+  completedAt: string | null;
+  createdAt: string;
+}
+
+function formatBytes(bytes: number | null): string {
+  if (bytes === null || bytes === 0) return '—';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i] ?? 'B'}`;
+}
 
 export function BackupsPage() {
-  const { serverId } = useParams();
+  const { orgId, serverId } = useParams();
+  const queryClient = useQueryClient();
+  const [showCreate, setShowCreate] = useState(false);
+  const [confirmRestore, setConfirmRestore] = useState<string | null>(null);
+
+  const { data } = useQuery({
+    queryKey: ['backups', orgId, serverId],
+    queryFn: () =>
+      api.get<{ backups: Backup[] }>(
+        `/organizations/${orgId}/servers/${serverId}/backups`,
+      ),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (backupId: string) =>
+      api.delete(`/organizations/${orgId}/servers/${serverId}/backups/${backupId}`),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: ['backups', orgId, serverId] }),
+  });
+
+  const restoreMutation = useMutation({
+    mutationFn: (backupId: string) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/backups/${backupId}/restore`, {}),
+    onSuccess: () => setConfirmRestore(null),
+  });
+
+  const lockMutation = useMutation({
+    mutationFn: (backupId: string) =>
+      api.patch(`/organizations/${orgId}/servers/${serverId}/backups/${backupId}/lock`, {}),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: ['backups', orgId, serverId] }),
+  });
+
+  const backupList = data?.backups ?? [];
+
+  const totalSize = backupList.reduce((sum, b) => sum + (b.sizeBytes ?? 0), 0);
 
   return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <div>
+          <h2 className="text-lg font-semibold">Backups</h2>
+          <p className="text-xs text-muted-foreground">
+            {backupList.length} backup{backupList.length !== 1 ? 's' : ''} — {formatBytes(totalSize)} total
+          </p>
+        </div>
+        <Dialog open={showCreate} onOpenChange={setShowCreate}>
+          <DialogTrigger asChild>
+            <Button size="sm">
+              <Plus className="mr-1.5 h-4 w-4" />
+              Create Backup
+            </Button>
+          </DialogTrigger>
+          <DialogContent>
+            <DialogHeader>
+              <DialogTitle>Create Backup</DialogTitle>
+            </DialogHeader>
+            <CreateBackupForm
+              orgId={orgId!}
+              serverId={serverId!}
+              onClose={() => setShowCreate(false)}
+            />
+          </DialogContent>
+        </Dialog>
+      </div>
+
+      {backupList.length === 0 ? (
         <Card>
           <CardContent className="flex flex-col items-center justify-center py-12">
             <HardDrive className="mb-4 h-12 w-12 text-muted-foreground/50" />
-        <p className="text-muted-foreground">Backup management coming soon</p>
+            <p className="text-muted-foreground">No backups yet</p>
-        <p className="mt-1 text-xs text-muted-foreground">Server: {serverId}</p>
+            <p className="mt-1 text-xs text-muted-foreground">
+              Create a backup to save the current state of your server
+            </p>
           </CardContent>
         </Card>
+      ) : (
+        <div className="space-y-3">
+          {backupList.map((backup) => (
+            <Card key={backup.id}>
+              <CardContent className="flex items-center justify-between py-4">
+                <div className="flex items-center gap-3">
+                  <div className="flex h-10 w-10 items-center justify-center rounded-lg bg-muted">
+                    {backup.completedAt ? (
+                      <CheckCircle2 className="h-5 w-5 text-green-500" />
+                    ) : (
+                      <Clock className="h-5 w-5 text-yellow-500 animate-pulse" />
+                    )}
+                  </div>
+                  <div>
+                    <div className="flex items-center gap-2">
+                      <p className="font-medium">{backup.name}</p>
+                      {backup.isLocked && (
+                        <Badge variant="outline">
+                          <Lock className="mr-1 h-3 w-3" />
+                          Locked
+                        </Badge>
+                      )}
+                      {!backup.completedAt && (
+                        <Badge variant="outline" className="text-yellow-500">
+                          In Progress
+                        </Badge>
+                      )}
+                    </div>
+                    <div className="mt-0.5 flex items-center gap-3 text-xs text-muted-foreground">
+                      <span>{formatBytes(backup.sizeBytes)}</span>
+                      <span>{new Date(backup.createdAt).toLocaleString()}</span>
+                      {backup.checksum && (
+                        <span className="font-mono">
+                          {backup.checksum.slice(0, 12)}...
+                        </span>
+                      )}
+                    </div>
+                  </div>
+                </div>
+
+                <div className="flex items-center gap-1">
+                  {backup.completedAt && (
+                    <>
+                      {confirmRestore === backup.id ? (
+                        <div className="flex items-center gap-1">
+                          <span className="text-xs text-destructive mr-1">Confirm?</span>
+                          <Button
+                            size="sm"
+                            variant="destructive"
+                            onClick={() => restoreMutation.mutate(backup.id)}
+                            disabled={restoreMutation.isPending}
+                          >
+                            Yes
+                          </Button>
+                          <Button
+                            size="sm"
+                            variant="outline"
+                            onClick={() => setConfirmRestore(null)}
+                          >
+                            No
+                          </Button>
+                        </div>
+                      ) : (
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          onClick={() => setConfirmRestore(backup.id)}
+                          title="Restore"
+                        >
+                          <RotateCcw className="h-4 w-4" />
+                        </Button>
+                      )}
+                    </>
+                  )}
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => lockMutation.mutate(backup.id)}
+                    title={backup.isLocked ? 'Unlock' : 'Lock'}
+                  >
+                    {backup.isLocked ? (
+                      <Unlock className="h-4 w-4" />
+                    ) : (
+                      <Lock className="h-4 w-4" />
+                    )}
+                  </Button>
+                  {!backup.isLocked && (
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      className="text-destructive hover:text-destructive"
+                      onClick={() => deleteMutation.mutate(backup.id)}
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </Button>
+                  )}
+                </div>
+              </CardContent>
+            </Card>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function CreateBackupForm({
+  orgId,
+  serverId,
+  onClose,
+}: {
+  orgId: string;
+  serverId: string;
+  onClose: () => void;
+}) {
+  const queryClient = useQueryClient();
+  const [name, setName] = useState(
+    `backup-${new Date().toISOString().slice(0, 10)}`,
+  );
+
+  const createMutation = useMutation({
+    mutationFn: (data: { name: string }) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/backups`, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['backups', orgId, serverId] });
+      onClose();
+    },
+  });
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        createMutation.mutate({ name });
+      }}
+      className="space-y-4"
+    >
+      <div className="grid gap-1.5">
+        <Label>Backup Name</Label>
+        <Input
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          required
+        />
+      </div>
+      <div className="flex justify-end gap-2 pt-2">
+        <Button type="button" variant="outline" onClick={onClose}>
+          Cancel
+        </Button>
+        <Button type="submit" disabled={createMutation.isPending}>
+          {createMutation.isPending ? 'Creating...' : 'Create Backup'}
+        </Button>
+      </div>
+    </form>
   );
 }

apps/web/src/pages/server/config.tsx

@@ -0,0 +1,190 @@
+import { useState } from 'react';
+import { useParams } from 'react-router';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Settings2, FileText, Save } from 'lucide-react';
+import { api } from '@/lib/api';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
+
+interface ConfigFile {
+  index: number;
+  path: string;
+  parser: string;
+  editableKeys: string[] | null;
+}
+
+interface ConfigEntry {
+  key: string;
+  value: string;
+}
+
+interface ConfigDetail {
+  path: string;
+  parser: string;
+  editableKeys: string[] | null;
+  entries: ConfigEntry[];
+  raw: string;
+}
+
+export function ConfigPage() {
+  const { orgId, serverId } = useParams();
+  const queryClient = useQueryClient();
+
+  const { data: configsData } = useQuery({
+    queryKey: ['configs', orgId, serverId],
+    queryFn: () =>
+      api.get<{ configs: ConfigFile[] }>(
+        `/organizations/${orgId}/servers/${serverId}/config`,
+      ),
+  });
+
+  const configs = configsData?.configs ?? [];
+
+  if (configs.length === 0) {
+    return (
+      <Card>
+        <CardContent className="flex flex-col items-center justify-center py-12">
+          <Settings2 className="mb-4 h-12 w-12 text-muted-foreground/50" />
+          <p className="text-muted-foreground">No config files available for this game</p>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <Tabs defaultValue="0" className="space-y-4">
+      <TabsList>
+        {configs.map((cf) => (
+          <TabsTrigger key={cf.index} value={String(cf.index)}>
+            <FileText className="mr-1.5 h-3.5 w-3.5" />
+            {cf.path.split('/').pop()}
+          </TabsTrigger>
+        ))}
+      </TabsList>
+
+      {configs.map((cf) => (
+        <TabsContent key={cf.index} value={String(cf.index)}>
+          <ConfigEditor
+            orgId={orgId!}
+            serverId={serverId!}
+            configIndex={cf.index}
+            configFile={cf}
+          />
+        </TabsContent>
+      ))}
+    </Tabs>
+  );
+}
+
+function ConfigEditor({
+  orgId,
+  serverId,
+  configIndex,
+  configFile,
+}: {
+  orgId: string;
+  serverId: string;
+  configIndex: number;
+  configFile: ConfigFile;
+}) {
+  const queryClient = useQueryClient();
+
+  const { data: detail } = useQuery({
+    queryKey: ['config-detail', orgId, serverId, configIndex],
+    queryFn: () =>
+      api.get<ConfigDetail>(
+        `/organizations/${orgId}/servers/${serverId}/config/${configIndex}`,
+      ),
+  });
+
+  const [entries, setEntries] = useState<ConfigEntry[]>([]);
+  const [initialized, setInitialized] = useState(false);
+
+  // Initialize entries from server data
+  if (detail && !initialized) {
+    setEntries(detail.entries);
+    setInitialized(true);
+  }
+
+  const saveMutation = useMutation({
+    mutationFn: (data: { entries: ConfigEntry[] }) =>
+      api.patch(
+        `/organizations/${orgId}/servers/${serverId}/config/${configIndex}`,
+        data,
+      ),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ['config-detail', orgId, serverId, configIndex],
+      });
+    },
+  });
+
+  const updateEntry = (key: string, value: string) => {
+    setEntries((prev) =>
+      prev.map((e) => (e.key === key ? { ...e, value } : e)),
+    );
+  };
+
+  const displayEntries = configFile.editableKeys
+    ? entries.filter((e) => configFile.editableKeys!.includes(e.key))
+    : entries;
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between">
+        <div>
+          <CardTitle className="flex items-center gap-2">
+            {configFile.path}
+            <Badge variant="outline">{configFile.parser}</Badge>
+          </CardTitle>
+          <CardDescription>
+            {configFile.editableKeys
+              ? `${configFile.editableKeys.length} editable keys`
+              : 'All keys editable'}
+          </CardDescription>
+        </div>
+        <Button
+          size="sm"
+          onClick={() => saveMutation.mutate({ entries })}
+          disabled={saveMutation.isPending}
+        >
+          <Save className="h-4 w-4" />
+          {saveMutation.isPending ? 'Saving...' : 'Save'}
+        </Button>
+      </CardHeader>
+      <CardContent>
+        {displayEntries.length === 0 ? (
+          <p className="py-8 text-center text-sm text-muted-foreground">
+            {detail ? 'No entries found. The server may need to be started first to generate config files.' : 'Loading...'}
+          </p>
+        ) : (
+          <div className="space-y-3">
+            {displayEntries.map((entry) => (
+              <div key={entry.key} className="grid gap-1.5">
+                <Label className="font-mono text-xs text-muted-foreground">
+                  {entry.key}
+                </Label>
+                <Input
+                  value={entry.value}
+                  onChange={(e) => updateEntry(entry.key, e.target.value)}
+                  className="font-mono text-sm"
+                />
+              </div>
+            ))}
+          </div>
+        )}
+
+        {saveMutation.isSuccess && (
+          <p className="mt-4 text-sm text-green-500">Config saved successfully</p>
+        )}
+        {saveMutation.isError && (
+          <p className="mt-4 text-sm text-destructive">Failed to save config</p>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

apps/web/src/pages/server/players.tsx

@@ -1,13 +1,81 @@
-import { Users } from 'lucide-react';
+import { useParams } from 'react-router';
+import { useQuery } from '@tanstack/react-query';
+import { Users, RefreshCw } from 'lucide-react';
+import { api } from '@/lib/api';
+import { Button } from '@/components/ui/button';
 import { Card, CardContent } from '@/components/ui/card';
 
+interface Player {
+  name: string;
+  steamid?: string;
+}
+
+interface PlayerListResponse {
+  players: Player[];
+  maxPlayers: number;
+}
+
 export function PlayersPage() {
+  const { orgId, serverId } = useParams();
+
+  const { data, isLoading, refetch } = useQuery({
+    queryKey: ['players', orgId, serverId],
+    queryFn: () =>
+      api.get<PlayerListResponse>(
+        `/organizations/${orgId}/servers/${serverId}/players`,
+      ),
+    refetchInterval: 30000,
+  });
+
+  const players = data?.players ?? [];
+  const maxPlayers = data?.maxPlayers ?? 0;
+
   return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <div>
+          <h2 className="text-lg font-semibold">Active Players</h2>
+          <p className="text-sm text-muted-foreground">
+            {players.length} / {maxPlayers} players online
+          </p>
+        </div>
+        <Button variant="outline" size="sm" onClick={() => refetch()} disabled={isLoading}>
+          <RefreshCw className={`h-4 w-4 ${isLoading ? 'animate-spin' : ''}`} />
+          Refresh
+        </Button>
+      </div>
+
+      {players.length === 0 ? (
         <Card>
           <CardContent className="flex flex-col items-center justify-center py-12">
             <Users className="mb-4 h-12 w-12 text-muted-foreground/50" />
-        <p className="text-muted-foreground">Active player tracking coming soon</p>
+            <p className="text-muted-foreground">No players online</p>
+            <p className="mt-1 text-xs text-muted-foreground">
+              Player tracking requires RCON to be enabled on the server
+            </p>
           </CardContent>
         </Card>
+      ) : (
+        <Card>
+          <CardContent className="p-0">
+            <div className="divide-y">
+              {players.map((player, i) => (
+                <div key={i} className="flex items-center gap-3 px-4 py-3">
+                  <div className="flex h-8 w-8 items-center justify-center rounded-full bg-primary/10 text-sm font-medium text-primary">
+                    {player.name.charAt(0).toUpperCase()}
+                  </div>
+                  <div>
+                    <p className="font-medium">{player.name}</p>
+                    {player.steamid && (
+                      <p className="text-xs text-muted-foreground">{player.steamid}</p>
+                    )}
+                  </div>
+                </div>
+              ))}
+            </div>
+          </CardContent>
+        </Card>
+      )}
+    </div>
   );
 }

apps/web/src/pages/server/plugins.tsx

@@ -1,12 +1,323 @@
-import { Puzzle } from 'lucide-react';
+import { useState } from 'react';
-import { Card, CardContent } from '@/components/ui/card';
+import { useParams } from 'react-router';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  Puzzle,
+  Search,
+  Download,
+  Trash2,
+  ToggleLeft,
+  ToggleRight,
+  Star,
+  Upload,
+} from 'lucide-react';
+import { api } from '@/lib/api';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from '@/components/ui/dialog';
+
+interface InstalledPlugin {
+  id: string;
+  pluginId: string;
+  name: string;
+  slug: string;
+  description: string | null;
+  source: 'spiget' | 'manual';
+  externalId: string | null;
+  installedVersion: string | null;
+  isActive: boolean;
+  installedAt: string;
+}
+
+interface SpigetResult {
+  id: number;
+  name: string;
+  tag: string;
+  downloads: number;
+  rating: { average: number; count: number };
+  updateDate: number;
+  external: boolean;
+}
 
 export function PluginsPage() {
+  const { orgId, serverId } = useParams();
+  const queryClient = useQueryClient();
+
+  const { data: pluginsData } = useQuery({
+    queryKey: ['plugins', orgId, serverId],
+    queryFn: () =>
+      api.get<{ plugins: InstalledPlugin[] }>(
+        `/organizations/${orgId}/servers/${serverId}/plugins`,
+      ),
+  });
+
+  const installed = pluginsData?.plugins ?? [];
+
+  return (
+    <Tabs defaultValue="installed" className="space-y-4">
+      <TabsList>
+        <TabsTrigger value="installed">
+          <Puzzle className="mr-1.5 h-3.5 w-3.5" />
+          Installed ({installed.length})
+        </TabsTrigger>
+        <TabsTrigger value="search">
+          <Search className="mr-1.5 h-3.5 w-3.5" />
+          Search Plugins
+        </TabsTrigger>
+        <TabsTrigger value="manual">
+          <Upload className="mr-1.5 h-3.5 w-3.5" />
+          Manual Install
+        </TabsTrigger>
+      </TabsList>
+
+      <TabsContent value="installed">
+        <InstalledPlugins installed={installed} orgId={orgId!} serverId={serverId!} />
+      </TabsContent>
+
+      <TabsContent value="search">
+        <SpigetSearch orgId={orgId!} serverId={serverId!} />
+      </TabsContent>
+
+      <TabsContent value="manual">
+        <ManualInstall orgId={orgId!} serverId={serverId!} />
+      </TabsContent>
+    </Tabs>
+  );
+}
+
+function InstalledPlugins({
+  installed,
+  orgId,
+  serverId,
+}: {
+  installed: InstalledPlugin[];
+  orgId: string;
+  serverId: string;
+}) {
+  const queryClient = useQueryClient();
+
+  const toggleMutation = useMutation({
+    mutationFn: (id: string) =>
+      api.patch(`/organizations/${orgId}/servers/${serverId}/plugins/${id}/toggle`),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['plugins', orgId, serverId] }),
+  });
+
+  const uninstallMutation = useMutation({
+    mutationFn: (id: string) =>
+      api.delete(`/organizations/${orgId}/servers/${serverId}/plugins/${id}`),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['plugins', orgId, serverId] }),
+  });
+
+  if (installed.length === 0) {
     return (
       <Card>
         <CardContent className="flex flex-col items-center justify-center py-12">
           <Puzzle className="mb-4 h-12 w-12 text-muted-foreground/50" />
-        <p className="text-muted-foreground">Plugin management coming soon</p>
+          <p className="text-muted-foreground">No plugins installed</p>
+          <p className="mt-1 text-xs text-muted-foreground">
+            Search for plugins or install manually
+          </p>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <div className="space-y-2">
+      {installed.map((plugin) => (
+        <Card key={plugin.id}>
+          <CardContent className="flex items-center justify-between p-4">
+            <div className="flex items-center gap-3">
+              <Puzzle className="h-5 w-5 text-primary" />
+              <div>
+                <div className="flex items-center gap-2">
+                  <p className="font-medium">{plugin.name}</p>
+                  <Badge variant="outline">{plugin.source}</Badge>
+                  {!plugin.isActive && <Badge variant="secondary">Disabled</Badge>}
+                </div>
+                {plugin.description && (
+                  <p className="text-sm text-muted-foreground">{plugin.description}</p>
+                )}
+              </div>
+            </div>
+            <div className="flex items-center gap-2">
+              <Button
+                size="icon"
+                variant="ghost"
+                onClick={() => toggleMutation.mutate(plugin.id)}
+                title={plugin.isActive ? 'Disable' : 'Enable'}
+              >
+                {plugin.isActive ? (
+                  <ToggleRight className="h-4 w-4 text-green-500" />
+                ) : (
+                  <ToggleLeft className="h-4 w-4 text-muted-foreground" />
+                )}
+              </Button>
+              <Button
+                size="icon"
+                variant="ghost"
+                onClick={() => uninstallMutation.mutate(plugin.id)}
+              >
+                <Trash2 className="h-4 w-4 text-destructive" />
+              </Button>
+            </div>
+          </CardContent>
+        </Card>
+      ))}
+    </div>
+  );
+}
+
+function SpigetSearch({ orgId, serverId }: { orgId: string; serverId: string }) {
+  const queryClient = useQueryClient();
+  const [query, setQuery] = useState('');
+  const [searchTerm, setSearchTerm] = useState('');
+
+  const { data: results, isLoading } = useQuery({
+    queryKey: ['spiget-search', orgId, serverId, searchTerm],
+    queryFn: () =>
+      api.get<{ results: SpigetResult[] }>(
+        `/organizations/${orgId}/servers/${serverId}/plugins/search`,
+        { q: searchTerm },
+      ),
+    enabled: searchTerm.length >= 2,
+  });
+
+  const installMutation = useMutation({
+    mutationFn: (resourceId: number) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/plugins/install/spiget`, {
+        resourceId,
+      }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['plugins', orgId, serverId] }),
+  });
+
+  const handleSearch = () => {
+    if (query.length >= 2) setSearchTerm(query);
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="flex gap-2">
+        <Input
+          placeholder="Search Spiget plugins (Minecraft only)..."
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+          onKeyDown={(e) => e.key === 'Enter' && handleSearch()}
+        />
+        <Button onClick={handleSearch} disabled={query.length < 2}>
+          <Search className="h-4 w-4" />
+          Search
+        </Button>
+      </div>
+
+      {isLoading && <p className="text-sm text-muted-foreground">Searching...</p>}
+
+      {results?.results && results.results.length === 0 && (
+        <p className="text-sm text-muted-foreground">No results found</p>
+      )}
+
+      <div className="space-y-2">
+        {results?.results?.map((r) => (
+          <Card key={r.id}>
+            <CardContent className="flex items-center justify-between p-4">
+              <div>
+                <p className="font-medium">{r.name}</p>
+                <p className="text-sm text-muted-foreground">{r.tag}</p>
+                <div className="mt-1 flex items-center gap-3 text-xs text-muted-foreground">
+                  <span className="flex items-center gap-1">
+                    <Star className="h-3 w-3" />
+                    {r.rating.average.toFixed(1)} ({r.rating.count})
+                  </span>
+                  <span>
+                    <Download className="inline h-3 w-3" /> {r.downloads.toLocaleString()}
+                  </span>
+                </div>
+              </div>
+              <Button
+                size="sm"
+                onClick={() => installMutation.mutate(r.id)}
+                disabled={installMutation.isPending || r.external}
+              >
+                <Download className="h-4 w-4" />
+                {r.external ? 'External' : 'Install'}
+              </Button>
+            </CardContent>
+          </Card>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function ManualInstall({ orgId, serverId }: { orgId: string; serverId: string }) {
+  const queryClient = useQueryClient();
+  const [name, setName] = useState('');
+  const [fileName, setFileName] = useState('');
+  const [version, setVersion] = useState('');
+
+  const installMutation = useMutation({
+    mutationFn: (body: { name: string; fileName: string; version?: string }) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/plugins/install/manual`, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['plugins', orgId, serverId] });
+      setName('');
+      setFileName('');
+      setVersion('');
+    },
+  });
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>Manual Plugin Install</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <form
+          className="space-y-4"
+          onSubmit={(e) => {
+            e.preventDefault();
+            installMutation.mutate({
+              name,
+              fileName,
+              version: version || undefined,
+            });
+          }}
+        >
+          <div className="space-y-2">
+            <Label>Plugin Name</Label>
+            <Input value={name} onChange={(e) => setName(e.target.value)} required />
+          </div>
+          <div className="space-y-2">
+            <Label>File Name</Label>
+            <Input
+              value={fileName}
+              onChange={(e) => setFileName(e.target.value)}
+              placeholder="plugin.jar"
+              required
+            />
+            <p className="text-xs text-muted-foreground">
+              Upload the file to /plugins/ directory via the Files tab first
+            </p>
+          </div>
+          <div className="space-y-2">
+            <Label>Version (optional)</Label>
+            <Input value={version} onChange={(e) => setVersion(e.target.value)} />
+          </div>
+          <Button type="submit" disabled={installMutation.isPending}>
+            {installMutation.isPending ? 'Registering...' : 'Register Plugin'}
+          </Button>
+        </form>
       </CardContent>
     </Card>
   );

apps/web/src/pages/server/schedules.tsx

@@ -1,13 +1,426 @@
-import { Calendar } from 'lucide-react';
+import { useState } from 'react';
-import { Card, CardContent } from '@/components/ui/card';
+import { useParams } from 'react-router';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  Calendar,
+  Plus,
+  Play,
+  Pause,
+  Trash2,
+  Clock,
+  Zap,
+  Terminal,
+  Power,
+  HardDrive,
+} from 'lucide-react';
+import { api } from '@/lib/api';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from '@/components/ui/dialog';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+
+interface ScheduledTask {
+  id: string;
+  name: string;
+  action: 'command' | 'power' | 'backup';
+  payload: string;
+  scheduleType: 'interval' | 'daily' | 'weekly' | 'cron';
+  scheduleData: Record<string, unknown>;
+  isActive: boolean;
+  lastRunAt: string | null;
+  nextRunAt: string | null;
+  createdAt: string;
+}
+
+const DAYS_OF_WEEK = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+const ACTION_ICONS = {
+  command: Terminal,
+  power: Power,
+  backup: HardDrive,
+} as const;
 
 export function SchedulesPage() {
+  const { orgId, serverId } = useParams();
+  const queryClient = useQueryClient();
+  const [showCreate, setShowCreate] = useState(false);
+
+  const { data } = useQuery({
+    queryKey: ['schedules', orgId, serverId],
+    queryFn: () =>
+      api.get<{ tasks: ScheduledTask[] }>(
+        `/organizations/${orgId}/servers/${serverId}/schedules`,
+      ),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (taskId: string) =>
+      api.delete(`/organizations/${orgId}/servers/${serverId}/schedules/${taskId}`),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: ['schedules', orgId, serverId] }),
+  });
+
+  const triggerMutation = useMutation({
+    mutationFn: (taskId: string) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/schedules/${taskId}/trigger`, {}),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: ['schedules', orgId, serverId] }),
+  });
+
+  const toggleMutation = useMutation({
+    mutationFn: ({ taskId, isActive }: { taskId: string; isActive: boolean }) =>
+      api.patch(`/organizations/${orgId}/servers/${serverId}/schedules/${taskId}`, { isActive }),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: ['schedules', orgId, serverId] }),
+  });
+
+  const tasks = data?.tasks ?? [];
+
   return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <h2 className="text-lg font-semibold">Scheduled Tasks</h2>
+        <Dialog open={showCreate} onOpenChange={setShowCreate}>
+          <DialogTrigger asChild>
+            <Button size="sm">
+              <Plus className="mr-1.5 h-4 w-4" />
+              New Schedule
+            </Button>
+          </DialogTrigger>
+          <DialogContent className="max-w-lg">
+            <DialogHeader>
+              <DialogTitle>Create Scheduled Task</DialogTitle>
+            </DialogHeader>
+            <CreateScheduleForm
+              orgId={orgId!}
+              serverId={serverId!}
+              onClose={() => setShowCreate(false)}
+            />
+          </DialogContent>
+        </Dialog>
+      </div>
+
+      {tasks.length === 0 ? (
         <Card>
           <CardContent className="flex flex-col items-center justify-center py-12">
             <Calendar className="mb-4 h-12 w-12 text-muted-foreground/50" />
-        <p className="text-muted-foreground">Scheduled tasks coming soon</p>
+            <p className="text-muted-foreground">No scheduled tasks yet</p>
+            <p className="mt-1 text-xs text-muted-foreground">
+              Create a schedule to automate commands, power actions, or backups
+            </p>
+          </CardContent>
+        </Card>
+      ) : (
+        <div className="space-y-3">
+          {tasks.map((task) => {
+            const ActionIcon = ACTION_ICONS[task.action];
+            return (
+              <Card key={task.id}>
+                <CardContent className="flex items-center justify-between py-4">
+                  <div className="flex items-center gap-3">
+                    <div className="flex h-10 w-10 items-center justify-center rounded-lg bg-muted">
+                      <ActionIcon className="h-5 w-5 text-muted-foreground" />
+                    </div>
+                    <div>
+                      <div className="flex items-center gap-2">
+                        <p className="font-medium">{task.name}</p>
+                        <Badge variant={task.isActive ? 'default' : 'outline'}>
+                          {task.isActive ? 'Active' : 'Paused'}
+                        </Badge>
+                        <Badge variant="outline">{task.action}</Badge>
+                      </div>
+                      <div className="mt-0.5 flex items-center gap-3 text-xs text-muted-foreground">
+                        <span className="flex items-center gap-1">
+                          <Clock className="h-3 w-3" />
+                          {formatSchedule(task.scheduleType, task.scheduleData)}
+                        </span>
+                        {task.nextRunAt && (
+                          <span>
+                            Next: {new Date(task.nextRunAt).toLocaleString()}
+                          </span>
+                        )}
+                        {task.lastRunAt && (
+                          <span>
+                            Last: {new Date(task.lastRunAt).toLocaleString()}
+                          </span>
+                        )}
+                      </div>
+                      {task.action === 'command' && (
+                        <p className="mt-0.5 font-mono text-xs text-muted-foreground">
+                          $ {task.payload}
+                        </p>
+                      )}
+                    </div>
+                  </div>
+
+                  <div className="flex items-center gap-1">
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => triggerMutation.mutate(task.id)}
+                      title="Run now"
+                    >
+                      <Zap className="h-4 w-4" />
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() =>
+                        toggleMutation.mutate({
+                          taskId: task.id,
+                          isActive: !task.isActive,
+                        })
+                      }
+                      title={task.isActive ? 'Pause' : 'Resume'}
+                    >
+                      {task.isActive ? (
+                        <Pause className="h-4 w-4" />
+                      ) : (
+                        <Play className="h-4 w-4" />
+                      )}
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      className="text-destructive hover:text-destructive"
+                      onClick={() => deleteMutation.mutate(task.id)}
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </Button>
+                  </div>
                 </CardContent>
               </Card>
             );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function formatSchedule(type: string, data: Record<string, unknown>): string {
+  switch (type) {
+    case 'interval':
+      return `Every ${data.minutes ?? 60} minutes`;
+    case 'daily':
+      return `Daily at ${String(data.hour ?? 0).padStart(2, '0')}:${String(data.minute ?? 0).padStart(2, '0')}`;
+    case 'weekly': {
+      const day = DAYS_OF_WEEK[Number(data.dayOfWeek ?? 0)] ?? 'Sunday';
+      return `${day} at ${String(data.hour ?? 0).padStart(2, '0')}:${String(data.minute ?? 0).padStart(2, '0')}`;
+    }
+    case 'cron':
+      return `Cron: ${String(data.expression ?? '* * * * *')}`;
+    default:
+      return type;
+  }
+}
+
+function CreateScheduleForm({
+  orgId,
+  serverId,
+  onClose,
+}: {
+  orgId: string;
+  serverId: string;
+  onClose: () => void;
+}) {
+  const queryClient = useQueryClient();
+  const [name, setName] = useState('');
+  const [action, setAction] = useState<'command' | 'power' | 'backup'>('command');
+  const [payload, setPayload] = useState('');
+  const [scheduleType, setScheduleType] = useState<'interval' | 'daily' | 'weekly' | 'cron'>('interval');
+
+  // Schedule data fields
+  const [minutes, setMinutes] = useState('60');
+  const [hour, setHour] = useState('0');
+  const [minute, setMinute] = useState('0');
+  const [dayOfWeek, setDayOfWeek] = useState('0');
+  const [cronExpression, setCronExpression] = useState('0 * * * *');
+
+  const createMutation = useMutation({
+    mutationFn: (data: Record<string, unknown>) =>
+      api.post(`/organizations/${orgId}/servers/${serverId}/schedules`, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['schedules', orgId, serverId] });
+      onClose();
+    },
+  });
+
+  const buildScheduleData = (): Record<string, unknown> => {
+    switch (scheduleType) {
+      case 'interval':
+        return { minutes: parseInt(minutes, 10) };
+      case 'daily':
+        return { hour: parseInt(hour, 10), minute: parseInt(minute, 10) };
+      case 'weekly':
+        return { dayOfWeek: parseInt(dayOfWeek, 10), hour: parseInt(hour, 10), minute: parseInt(minute, 10) };
+      case 'cron':
+        return { expression: cronExpression };
+    }
+  };
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    createMutation.mutate({
+      name,
+      action,
+      payload: action === 'backup' ? 'backup' : payload,
+      scheduleType,
+      scheduleData: buildScheduleData(),
+    });
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="space-y-4">
+      <div className="grid gap-1.5">
+        <Label>Name</Label>
+        <Input
+          placeholder="Daily restart"
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          required
+        />
+      </div>
+
+      <div className="grid grid-cols-2 gap-3">
+        <div className="grid gap-1.5">
+          <Label>Action</Label>
+          <Select value={action} onValueChange={(v) => setAction(v as typeof action)}>
+            <SelectTrigger><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="command">Run Command</SelectItem>
+              <SelectItem value="power">Power Action</SelectItem>
+              <SelectItem value="backup">Create Backup</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+
+        {action !== 'backup' && (
+          <div className="grid gap-1.5">
+            <Label>{action === 'command' ? 'Command' : 'Power Action'}</Label>
+            {action === 'command' ? (
+              <Input
+                placeholder="say Server restarting..."
+                value={payload}
+                onChange={(e) => setPayload(e.target.value)}
+                required
+              />
+            ) : (
+              <Select value={payload} onValueChange={setPayload}>
+                <SelectTrigger><SelectValue placeholder="Select..." /></SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="start">Start</SelectItem>
+                  <SelectItem value="stop">Stop</SelectItem>
+                  <SelectItem value="restart">Restart</SelectItem>
+                  <SelectItem value="kill">Kill</SelectItem>
+                </SelectContent>
+              </Select>
+            )}
+          </div>
+        )}
+      </div>
+
+      <div className="grid gap-1.5">
+        <Label>Schedule Type</Label>
+        <Select value={scheduleType} onValueChange={(v) => setScheduleType(v as typeof scheduleType)}>
+          <SelectTrigger><SelectValue /></SelectTrigger>
+          <SelectContent>
+            <SelectItem value="interval">Interval</SelectItem>
+            <SelectItem value="daily">Daily</SelectItem>
+            <SelectItem value="weekly">Weekly</SelectItem>
+            <SelectItem value="cron">Cron Expression</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+
+      {scheduleType === 'interval' && (
+        <div className="grid gap-1.5">
+          <Label>Interval (minutes)</Label>
+          <Input
+            type="number"
+            min="1"
+            value={minutes}
+            onChange={(e) => setMinutes(e.target.value)}
+          />
+        </div>
+      )}
+
+      {(scheduleType === 'daily' || scheduleType === 'weekly') && (
+        <div className="grid grid-cols-2 gap-3">
+          {scheduleType === 'weekly' && (
+            <div className="col-span-2 grid gap-1.5">
+              <Label>Day of Week</Label>
+              <Select value={dayOfWeek} onValueChange={setDayOfWeek}>
+                <SelectTrigger><SelectValue /></SelectTrigger>
+                <SelectContent>
+                  {DAYS_OF_WEEK.map((day, i) => (
+                    <SelectItem key={day} value={String(i)}>{day}</SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+          )}
+          <div className="grid gap-1.5">
+            <Label>Hour (0-23)</Label>
+            <Input
+              type="number"
+              min="0"
+              max="23"
+              value={hour}
+              onChange={(e) => setHour(e.target.value)}
+            />
+          </div>
+          <div className="grid gap-1.5">
+            <Label>Minute (0-59)</Label>
+            <Input
+              type="number"
+              min="0"
+              max="59"
+              value={minute}
+              onChange={(e) => setMinute(e.target.value)}
+            />
+          </div>
+        </div>
+      )}
+
+      {scheduleType === 'cron' && (
+        <div className="grid gap-1.5">
+          <Label>Cron Expression</Label>
+          <Input
+            placeholder="0 */6 * * *"
+            value={cronExpression}
+            onChange={(e) => setCronExpression(e.target.value)}
+            className="font-mono"
+          />
+          <p className="text-xs text-muted-foreground">
+            Format: minute hour day-of-month month day-of-week
+          </p>
+        </div>
+      )}
+
+      <div className="flex justify-end gap-2 pt-2">
+        <Button type="button" variant="outline" onClick={onClose}>
+          Cancel
+        </Button>
+        <Button type="submit" disabled={createMutation.isPending}>
+          {createMutation.isPending ? 'Creating...' : 'Create Schedule'}
+        </Button>
+      </div>
+    </form>
+  );
 }

packages/shared/src/permissions.ts

@@ -16,10 +16,12 @@ export const PERMISSIONS = {
   'files.archive': 'Compress and decompress files',
 
   // Backup
+  'backup.read': 'View backups',
   'backup.create': 'Create backups',
   'backup.restore': 'Restore backups',
   'backup.delete': 'Delete backups',
   'backup.download': 'Download backups',
+  'backup.manage': 'Lock and manage backups',
 
   // Schedule
   'schedule.read': 'View scheduled tasks',

packages/shared/src/types.ts

@@ -8,6 +8,26 @@ export type ScheduleAction = 'command' | 'power' | 'backup';
 
 export type PluginSource = 'spiget' | 'manual';
 
+export type ConfigParser = 'properties' | 'json' | 'yaml' | 'keyvalue';
+
+export interface GameConfigFile {
+  path: string;
+  parser: ConfigParser;
+  editableKeys?: string[];
+}
+
+export interface GameEnvVar {
+  key: string;
+  default: string;
+  description: string;
+  required: boolean;
+}
+
+export interface ConfigEntry {
+  key: string;
+  value: string;
+}
+
 export interface PaginationParams {
   page: number;
   perPage: number;