Add multi-server blueprint collections and atomic launches

src/lib/server/db/schema.sql

@@ -361,6 +361,28 @@ CREATE TABLE IF NOT EXISTS server_launch_recipes (
     blueprint_name TEXT
 );
 
+CREATE TABLE IF NOT EXISTS server_launch_collections (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS server_collection_members (
+    collection_id TEXT NOT NULL REFERENCES server_launch_collections(id) ON DELETE CASCADE,
+    deployment_id TEXT NOT NULL UNIQUE REFERENCES server_deployments(id) ON DELETE CASCADE,
+    position INTEGER NOT NULL,
+    PRIMARY KEY (collection_id, position)
+);
+
+CREATE TABLE IF NOT EXISTS server_collection_previews (
+    id TEXT PRIMARY KEY,
+    expires_at TEXT NOT NULL,
+    blueprint_name TEXT NOT NULL,
+    entries TEXT NOT NULL,
+    servers TEXT NOT NULL,
+    collection_id TEXT REFERENCES server_launch_collections(id) ON DELETE CASCADE
+);
+
 -- Persist state transitions atomically, including changes made by background workers.
 -- Polls with unchanged status/error do not produce duplicate activity entries.
 CREATE TABLE IF NOT EXISTS beta_events (

src/lib/server/fleet/collections.ts

@@ -0,0 +1,113 @@
+import { randomUUID } from 'node:crypto';
+import type { CollectionDetail, CollectionPreview, CollectionSummary } from '$lib/deployment-plan.js';
+import { db } from '../db/index.js';
+import { config, configFileForGame, komodoConfigured, rconConfigured } from '../config.js';
+import { blueprintEntries, summarizeRecipe, type BlueprintEntry } from './launch-recipes.js';
+import { nextAvailablePort, nextLobbyNumber, queueCreateServer } from './create.js';
+import { getServerKey } from './server-keys.js';
+
+function allocate(entries: BlueprintEntry[]): CollectionPreview['servers'] {
+    const names: string[] = [];
+    const ports: number[] = [];
+    return entries.flatMap((entry, entryIndex) => Array.from({ length: entry.count }, () => {
+        const base = `${entry.recipe.game}_zombie_${entry.recipe.mapSlug}`;
+        const lobby = nextLobbyNumber(base, names);
+        const name = lobby === null ? null : `${base}_${lobby}`;
+        const port = nextAvailablePort(ports);
+        if (name) names.push(name);
+        if (port !== null) ports.push(port);
+        return { entryIndex, name, port, hasSavedKey: !!name && !!getServerKey(name) };
+    }));
+}
+
+function blockersFor(entries: BlueprintEntry[], servers: CollectionPreview['servers']): string[] {
+    const blockers: string[] = [];
+    if (!komodoConfigured() || !config.komodo.targetServer) blockers.push('Configure Komodo credentials and a target host before launching.');
+    if (!rconConfigured()) blockers.push('Configure RCON_PASSWORD so every new server can be verified.');
+    if (servers.some(server => !server.name)) blockers.push('There are not enough free lobbies for one or more maps (20 per map). Reduce their counts or free capacity.');
+    if (servers.some(server => server.port === null)) blockers.push(`There are not enough free game ports in ${config.portRange.min}–${config.portRange.max} for the whole collection.`);
+    if (entries.some(entry => entry.recipe.configFile !== configFileForGame(entry.recipe.game))) blockers.push('A saved config filename no longer matches the host settings. Create a new blueprint with the current setup.');
+    return blockers;
+}
+
+export function previewCollection(blueprintId: unknown): CollectionPreview {
+    if (typeof blueprintId !== 'string' || !blueprintId) throw new Error('Choose a blueprint to launch.');
+    return db().transaction(() => {
+        const { entries, blueprintName } = blueprintEntries(blueprintId);
+        const servers = allocate(entries);
+        const blockers = blockersFor(entries, servers);
+        const id = randomUUID();
+        const expiresAt = new Date(Date.now() + 30 * 60_000).toISOString();
+        db().prepare('DELETE FROM server_collection_previews WHERE expires_at < ? AND collection_id IS NULL').run(new Date().toISOString());
+        db().prepare('INSERT INTO server_collection_previews (id, expires_at, blueprint_name, entries, servers) VALUES (?, ?, ?, ?, ?)')
+            .run(id, expiresAt, blueprintName, JSON.stringify(entries), JSON.stringify(servers));
+        return { id, expiresAt, blueprintName, servers, blockers, ready: blockers.length === 0,
+            entries: entries.map(entry => ({ count: entry.count, recipe: summarizeRecipe(entry.recipe) })) };
+    })();
+}
+
+/** Reserve and enqueue the entire collection atomically. No external operations here. */
+export function queueCollection(input: { previewId?: unknown; keys?: unknown }): { ok: true; collectionId: string } {
+    if (typeof input.previewId !== 'string' || !input.previewId) throw new Error('Review a collection preview before launching.');
+    if (input.keys !== undefined && (!input.keys || typeof input.keys !== 'object' || Array.isArray(input.keys))) throw new Error('Provide keys indexed by the exact server ID.');
+    const keys = (input.keys ?? {}) as Record<string, unknown>;
+    return db().transaction(() => {
+        const preview = db().prepare('SELECT * FROM server_collection_previews WHERE id = ?').get(input.previewId) as {
+            id: string; expires_at: string; blueprint_name: string; entries: string; servers: string; collection_id: string | null;
+        } | undefined;
+        if (!preview) throw new Error('Collection preview expired or was not found. Refresh the preview.');
+        if (preview.collection_id) return { ok: true as const, collectionId: preview.collection_id };
+        if (preview.expires_at <= new Date().toISOString()) throw new Error('Collection preview expired. Refresh it before launching.');
+        const entries: BlueprintEntry[] = JSON.parse(preview.entries);
+        const reviewed: CollectionPreview['servers'] = JSON.parse(preview.servers);
+        const servers = allocate(entries);
+        const blockers = blockersFor(entries, servers);
+        if (blockers.length) throw new Error(blockers.join(' '));
+        if (servers.some((server, i) => server.name !== reviewed[i]?.name || server.port !== reviewed[i]?.port)) {
+            throw new Error('Lobby or port availability changed. Nothing was queued. Refresh the preview and review each server key.');
+        }
+        const expected = new Set(servers.map(server => server.name));
+        for (const [name, value] of Object.entries(keys)) {
+            if (!expected.has(name) || typeof value !== 'string') throw new Error('Keys must be strings for server IDs shown in this preview.');
+        }
+        const collectionId = randomUUID();
+        db().prepare('INSERT INTO server_launch_collections (id, name, created_at) VALUES (?, ?, ?)')
+            .run(collectionId, preview.blueprint_name, new Date().toISOString());
+        servers.forEach((server, index) => {
+            const recipe = entries[server.entryIndex].recipe;
+            const childPreviewId = randomUUID();
+            db().prepare('INSERT INTO server_launch_previews (id, expires_at, server, port, recipe, blueprint_name) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(childPreviewId, preview.expires_at, server.name, server.port, JSON.stringify(recipe), preview.blueprint_name);
+            const result = queueCreateServer({ game: recipe.game, gameMode: 'zombie', mapSlug: recipe.mapSlug,
+                expectedName: server.name!, previewId: childPreviewId, plutoKey: keys[server.name!] as string | undefined, createdBy: 'ui' });
+            // Throw so the outer transaction also reverses all earlier keys and children.
+            if (!result.ok) throw new Error(`${server.name}: ${result.message} Nothing was queued.`);
+            db().prepare('INSERT INTO server_collection_members (collection_id, deployment_id, position) VALUES (?, ?, ?)')
+                .run(collectionId, result.deploymentId, index);
+        });
+        db().prepare('UPDATE server_collection_previews SET collection_id = ? WHERE id = ?').run(collectionId, preview.id);
+        return { ok: true as const, collectionId };
+    })();
+}
+
+const summarySql = `SELECT c.id, c.name, c.created_at, COUNT(d.id) AS total,
+    COALESCE(SUM(d.state IN ('done', 'warning')), 0) AS done,
+    COALESCE(SUM(d.state IN ('failed', 'interrupted')), 0) AS failed,
+    COALESCE(SUM(d.state IN ('queued', 'running', 'awaiting-health', 'waiting')), 0) AS active
+    FROM server_launch_collections c
+    LEFT JOIN server_collection_members m ON m.collection_id = c.id
+    LEFT JOIN server_deployments d ON d.id = m.deployment_id`;
+
+export function listCollections(): CollectionSummary[] {
+    return db().prepare(summarySql + ' GROUP BY c.id ORDER BY c.created_at DESC, c.rowid DESC').all() as CollectionSummary[];
+}
+
+export function getCollection(id: string): CollectionDetail | null {
+    const collection = db().prepare(summarySql + ' WHERE c.id = ? GROUP BY c.id').get(id) as CollectionSummary | undefined;
+    if (!collection) return null;
+    const servers = db().prepare(`SELECT d.id, d.server, d.state, d.stage, d.started_at, d.finished_at, d.error, j.port, j.map_slug,
+        EXISTS(SELECT 1 FROM servers s WHERE s.name = d.server) AS server_exists
+        FROM server_collection_members m JOIN server_deployments d ON d.id = m.deployment_id
+        JOIN server_creation_jobs j ON j.deployment_id = d.id WHERE m.collection_id = ? ORDER BY m.position`).all(id) as CollectionDetail['servers'];
+    return { collection, servers };
+}

src/lib/server/fleet/create.ts

@@ -59,7 +59,7 @@ export interface CreateServerInput {
  * the servers table. Caps at 20 to stay inside the port range — with 20 total
  * ports across the whole fleet, no one map can hold more than that.
  */
-function nextLobbyNumber(baseName: string): number | null {
+export function nextLobbyNumber(baseName: string, additionalNames: string[] = []): number | null {
     const rows = db()
         .prepare(`SELECT name FROM servers WHERE name LIKE ? UNION
             SELECT j.server AS name FROM server_creation_jobs j JOIN server_deployments d ON d.id = j.deployment_id
@@ -67,7 +67,7 @@ function nextLobbyNumber(baseName: string): number | null {
         .all(`${baseName}_%`) as Array<{ name: string }>;
     const taken = new Set<number>();
     const prefix = `${baseName}_`;
-    for (const r of rows) {
+    for (const r of [...rows, ...additionalNames.map(name => ({ name }))]) {
         if (!r.name.startsWith(prefix)) continue;
         const tail = r.name.slice(prefix.length);
         if (/^\d+$/.test(tail)) taken.add(Number.parseInt(tail, 10));
@@ -83,13 +83,13 @@ function nextLobbyNumber(baseName: string): number | null {
  * from the DB (which EC controls end-to-end under the new naming scheme, so
  * the DB is authoritative — no need to ask Komodo).
  */
-function nextAvailablePort(): number | null {
+export function nextAvailablePort(additionalPorts: number[] = []): number | null {
     const rows = db()
         .prepare(`SELECT game_port FROM servers WHERE game_port IS NOT NULL UNION
             SELECT j.port AS game_port FROM server_creation_jobs j JOIN server_deployments d ON d.id = j.deployment_id
             WHERE d.state IN ('queued', 'running', 'awaiting-health')`)
         .all() as Array<{ game_port: number }>;
-    const taken = new Set(rows.map((r) => r.game_port));
+    const taken = new Set([...rows.map((r) => r.game_port), ...additionalPorts]);
     for (let p = config.portRange.min; p <= config.portRange.max; p++) {
         if (!taken.has(p)) return p;
     }

src/lib/server/fleet/deployments.ts

@@ -27,8 +27,10 @@ export function getDeployment(id: string) {
     if (!deployment) return null;
     const events = db().prepare('SELECT id, created_at, message FROM server_deployment_events WHERE deployment_id = ? ORDER BY id').all(id);
     const launch = recipeForDeployment(id);
+    const collection = db().prepare(`SELECT c.id, c.name FROM server_collection_members m
+        JOIN server_launch_collections c ON c.id = m.collection_id WHERE m.deployment_id = ?`).get(id) ?? null;
     return { deployment, events, recipe: launch ? summarizeRecipe(launch.recipe) : null, blueprintName: launch?.blueprintName ?? null,
-        canResumeVerification: canResumeVerification(id) };
+        canResumeVerification: canResumeVerification(id), collection };
 }
 
 export function canResumeVerification(id: string): boolean {

src/lib/server/fleet/launch-recipes.ts

@@ -21,6 +21,44 @@ export interface LaunchRecipe {
     files: (LaunchFileSummary & { content: string })[];
 }
 
+export interface BlueprintEntry { count: number; recipe: LaunchRecipe }
+interface BlueprintRow { id: string; name: string; description: string; created_at: string; recipe: string }
+
+/** Existing one-server blueprints remain usable without a destructive migration. */
+function readEntries(raw: string): BlueprintEntry[] {
+    const saved = JSON.parse(raw) as LaunchRecipe | { format: 2; entries: BlueprintEntry[] };
+    return saved.format === 2 ? saved.entries : [{ count: 1, recipe: saved }];
+}
+
+function summarizeBlueprint(row: BlueprintRow): BlueprintSummary {
+    const entries = readEntries(row.recipe).map(entry => ({ count: entry.count, recipe: summarizeRecipe(entry.recipe) }));
+    return { id: row.id, name: row.name, description: row.description, createdAt: row.created_at,
+        recipe: entries[0].recipe, entries, totalServers: entries.reduce((total, entry) => total + entry.count, 0) };
+}
+
+export function blueprintEntries(id: string): { entries: BlueprintEntry[]; blueprintName: string } {
+    const row = db().prepare('SELECT * FROM server_blueprints WHERE id = ?').get(id) as BlueprintRow | undefined;
+    if (!row) throw new Error('This blueprint is no longer available. Choose another starting point.');
+    return { entries: readEntries(row.recipe), blueprintName: row.name };
+}
+
+function buildEntries(input: unknown, prior: BlueprintEntry[] = []): BlueprintEntry[] {
+    if (!Array.isArray(input) || input.length < 1 || input.length > 40) throw new Error('Add between 1 and 40 map selections.');
+    const seen = new Set<string>();
+    const entries = input.map(entry => {
+        if (!entry || (entry.game !== 't5' && entry.game !== 't6') || typeof entry.mapSlug !== 'string'
+            || !zombieMapBySlug(entry.game, entry.mapSlug)) throw new Error('Each selection needs a supported game and map.');
+        if (!Number.isSafeInteger(entry.count) || entry.count < 1 || entry.count > 20) throw new Error('Choose 1–20 lobbies for each map.');
+        const key = `${entry.game}:${entry.mapSlug}`;
+        if (seen.has(key)) throw new Error('Each game/map can appear once. Increase its lobby count instead.');
+        seen.add(key);
+        const previous = prior.find(item => item.recipe.game === entry.game && item.recipe.mapSlug === entry.mapSlug);
+        return { count: entry.count as number, recipe: previous?.recipe ?? captureRecipe(entry.game, entry.mapSlug) };
+    });
+    if (entries.reduce((total, entry) => total + entry.count, 0) > 100) throw new Error('A blueprint can launch at most 100 servers.');
+    return entries;
+}
+
 export function captureRecipe(game: ZombieGame, mapSlug: string): LaunchRecipe {
     const map = zombieMapBySlug(game, mapSlug);
     if (!map) throw new Error('Choose a supported game and map.');
@@ -59,35 +97,52 @@ export function recipeForDeployment(id: string): { recipe: LaunchRecipe; bluepri
 }
 
 export function blueprintRecipe(id: string): { recipe: LaunchRecipe; blueprintName: string } {
-    const row = db().prepare('SELECT recipe, name FROM server_blueprints WHERE id = ?').get(id) as { recipe: string; name: string } | undefined;
-    if (!row) throw new Error('This blueprint is no longer available. Choose another starting point.');
-    return { recipe: JSON.parse(row.recipe), blueprintName: row.name };
+    const { entries, blueprintName } = blueprintEntries(id);
+    if (entries.length !== 1 || entries[0].count !== 1) throw new Error('This blueprint launches multiple servers. Use the collection preview.');
+    return { recipe: entries[0].recipe, blueprintName };
 }
 
 export function listBlueprints(): BlueprintSummary[] {
-    return (db().prepare('SELECT * FROM server_blueprints ORDER BY name COLLATE NOCASE').all() as {
-        id: string; name: string; description: string; created_at: string; recipe: string;
-    }[]).map(row => ({ id: row.id, name: row.name, description: row.description,
-        createdAt: row.created_at, recipe: summarizeRecipe(JSON.parse(row.recipe)) }));
+    return (db().prepare('SELECT * FROM server_blueprints ORDER BY name COLLATE NOCASE').all() as BlueprintRow[]).map(summarizeBlueprint);
 }
 
-export function saveBlueprint(input: { name: unknown; description?: unknown; previewId?: unknown; deploymentId?: unknown }): BlueprintSummary {
+function blueprintName(input: { name: unknown; description?: unknown }, exceptId = ''): string {
     if (typeof input.name !== 'string' || !input.name.trim() || input.name.trim().length > 80) throw new Error('Give the blueprint a name of 1–80 characters.');
     if (input.description !== undefined && (typeof input.description !== 'string' || input.description.length > 500)) throw new Error('Keep the description to 500 characters.');
-    if ((typeof input.previewId === 'string') === (typeof input.deploymentId === 'string')) throw new Error('Choose exactly one launch preview or recorded deployment.');
+    if (db().prepare('SELECT id FROM server_blueprints WHERE name = ? COLLATE NOCASE AND id != ?').get(input.name.trim(), exceptId)) throw new Error('A blueprint with this name already exists. Choose a new name.');
+    return input.name.trim();
+}
+
+export function saveBlueprint(input: { name: unknown; description?: unknown; previewId?: unknown; deploymentId?: unknown; entries?: unknown }): BlueprintSummary {
+    const name = blueprintName(input);
+    if ([input.previewId, input.deploymentId, input.entries].filter(value => value !== undefined).length !== 1) throw new Error('Choose exactly one launch preview, recorded deployment, or set of maps.');
     let recipe: LaunchRecipe | undefined;
     if (typeof input.previewId === 'string') {
         const row = db().prepare('SELECT recipe FROM server_launch_previews WHERE id = ? AND expires_at > ?')
             .get(input.previewId, new Date().toISOString()) as { recipe: string } | undefined;
         if (row) recipe = JSON.parse(row.recipe);
     } else if (typeof input.deploymentId === 'string') recipe = recipeForDeployment(input.deploymentId)?.recipe;
-    if (!recipe) throw new Error('The launch recipe is unavailable or the preview expired. Generate a fresh preview.');
-    if (db().prepare('SELECT id FROM server_blueprints WHERE name = ? COLLATE NOCASE').get(input.name.trim())) throw new Error('A blueprint with this name already exists. Choose a new name.');
+    if (!recipe && input.entries === undefined) throw new Error('The launch recipe is unavailable or the preview expired. Generate a fresh preview.');
+    const entries = input.entries !== undefined ? buildEntries(input.entries) : [{ count: 1, recipe: recipe! }];
     const id = randomUUID();
     const createdAt = new Date().toISOString();
+    const saved = JSON.stringify({ format: 2, entries });
     db().prepare('INSERT INTO server_blueprints (id, name, description, created_at, recipe) VALUES (?, ?, ?, ?, ?)')
-        .run(id, input.name.trim(), input.description ?? '', createdAt, JSON.stringify(recipe));
-    return { id, name: input.name.trim(), description: (input.description as string) ?? '', createdAt, recipe: summarizeRecipe(recipe) };
+        .run(id, name, input.description ?? '', createdAt, saved);
+    return summarizeBlueprint({ id, name, description: (input.description as string) ?? '', created_at: createdAt, recipe: saved });
+}
+
+export function updateBlueprint(id: string, input: { name: unknown; description?: unknown; entries?: unknown }): BlueprintSummary {
+    return db().transaction(() => {
+        const row = db().prepare('SELECT * FROM server_blueprints WHERE id = ?').get(id) as BlueprintRow | undefined;
+        if (!row) throw new Error('Blueprint not found.');
+        const name = blueprintName(input, id);
+        const entries = buildEntries(input.entries, readEntries(row.recipe));
+        const recipe = JSON.stringify({ format: 2, entries });
+        const description = (input.description as string) ?? '';
+        db().prepare('UPDATE server_blueprints SET name = ?, description = ?, recipe = ? WHERE id = ?').run(name, description, recipe, id);
+        return summarizeBlueprint({ ...row, name, description, recipe });
+    })();
 }
 
 export function deleteBlueprint(id: string): boolean {