swarmy 0.1.1 → 0.1.2

package/manager/src/server/auth.ts

@@ -0,0 +1,52 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { Request, Response, NextFunction } from "express";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TOKEN_PATH = path.join(__dirname, "../../data/token");
+
+let cachedToken: string | null = null;
+
+export function getToken(): string {
+  if (cachedToken) return cachedToken;
+
+  // Allow env var override
+  if (process.env.SWARM_TOKEN) {
+    cachedToken = process.env.SWARM_TOKEN;
+    return cachedToken;
+  }
+
+  const tokenDir = path.dirname(TOKEN_PATH);
+  fs.mkdirSync(tokenDir, { recursive: true });
+
+  if (fs.existsSync(TOKEN_PATH)) {
+    cachedToken = fs.readFileSync(TOKEN_PATH, "utf-8").trim();
+  } else {
+    cachedToken = crypto.randomBytes(32).toString("hex");
+    fs.writeFileSync(TOKEN_PATH, cachedToken, { mode: 0o600 });
+  }
+
+  return cachedToken;
+}
+
+export function validateToken(token: string): boolean {
+  return token === getToken();
+}
+
+export function authMiddleware(req: Request, res: Response, next: NextFunction): void {
+  const header = req.headers.authorization;
+  if (!header || !header.startsWith("Bearer ")) {
+    res.status(401).json({ error: "Missing or invalid Authorization header" });
+    return;
+  }
+
+  const token = header.slice(7);
+  if (!validateToken(token)) {
+    res.status(403).json({ error: "Invalid token" });
+    return;
+  }
+
+  next();
+}

package/manager/src/server/db.ts

@@ -0,0 +1,251 @@
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DB_PATH = path.join(__dirname, "../../data/swarm.db");
+
+let db: Database.Database;
+
+export function getDb(): Database.Database {
+  if (!db) {
+    fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    initSchema(db);
+  }
+  return db;
+}
+
+function initSchema(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS nodes (
+      id              TEXT PRIMARY KEY,
+      hostname        TEXT,
+      ip              TEXT,
+      status          TEXT DEFAULT 'offline',
+      max_containers  INTEGER DEFAULT 5,
+      last_heartbeat  INTEGER,
+      created_at      INTEGER DEFAULT (unixepoch()),
+      updated_at      INTEGER DEFAULT (unixepoch())
+    );
+
+    CREATE TABLE IF NOT EXISTS containers (
+      id              TEXT PRIMARY KEY,
+      node_id         TEXT REFERENCES nodes(id),
+      docker_id       TEXT,
+      image           TEXT DEFAULT 'swarm-base',
+      status          TEXT DEFAULT 'running',
+      vnc_port        INTEGER,
+      max_sessions    INTEGER DEFAULT 10,
+      created_at      INTEGER DEFAULT (unixepoch()),
+      updated_at      INTEGER DEFAULT (unixepoch())
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id              TEXT PRIMARY KEY,
+      container_id    TEXT REFERENCES containers(id),
+      command         TEXT DEFAULT 'bash',
+      status          TEXT DEFAULT 'running',
+      exit_code       INTEGER,
+      interactive     INTEGER DEFAULT 1,
+      scrollback      TEXT DEFAULT '',
+      created_at      INTEGER DEFAULT (unixepoch()),
+      updated_at      INTEGER DEFAULT (unixepoch())
+    );
+  `);
+}
+
+// --- Node queries ---
+
+export function upsertNode(
+  id: string,
+  hostname: string,
+  ip: string,
+  maxContainers: number
+): void {
+  getDb()
+    .prepare(
+      `INSERT INTO nodes (id, hostname, ip, status, max_containers, last_heartbeat, updated_at)
+       VALUES (?, ?, ?, 'online', ?, unixepoch(), unixepoch())
+       ON CONFLICT(id) DO UPDATE SET
+         hostname = excluded.hostname,
+         ip = excluded.ip,
+         status = 'online',
+         max_containers = excluded.max_containers,
+         last_heartbeat = unixepoch(),
+         updated_at = unixepoch()`
+    )
+    .run(id, hostname, ip, maxContainers);
+}
+
+export function updateNodeHeartbeat(id: string): void {
+  getDb()
+    .prepare(
+      `UPDATE nodes SET last_heartbeat = unixepoch(), status = 'online', updated_at = unixepoch() WHERE id = ?`
+    )
+    .run(id);
+}
+
+export function markNodeStatus(id: string, status: string): void {
+  getDb()
+    .prepare(`UPDATE nodes SET status = ?, updated_at = unixepoch() WHERE id = ?`)
+    .run(status, id);
+}
+
+export function getAllNodes(): any[] {
+  return getDb().prepare(`SELECT * FROM nodes ORDER BY created_at`).all();
+}
+
+export function getNode(id: string): any {
+  return getDb().prepare(`SELECT * FROM nodes WHERE id = ?`).get(id);
+}
+
+export function getStaleNodes(thresholdSeconds: number): any[] {
+  return getDb()
+    .prepare(
+      `SELECT * FROM nodes WHERE status = 'online' AND last_heartbeat < unixepoch() - ?`
+    )
+    .all(thresholdSeconds);
+}
+
+export function markReconnectingNodes(): void {
+  getDb()
+    .prepare(
+      `UPDATE nodes SET status = 'reconnecting', updated_at = unixepoch() WHERE status = 'online'`
+    )
+    .run();
+}
+
+export function removeNode(id: string): void {
+  const containers = getContainersByNode(id);
+  for (const c of containers) {
+    getDb().prepare(`DELETE FROM sessions WHERE container_id = ?`).run(c.id);
+  }
+  getDb().prepare(`DELETE FROM containers WHERE node_id = ?`).run(id);
+  getDb().prepare(`DELETE FROM nodes WHERE id = ?`).run(id);
+}
+
+export function markStaleReconnectingOffline(thresholdSeconds: number): number {
+  return getDb()
+    .prepare(
+      `UPDATE nodes SET status = 'offline', updated_at = unixepoch()
+       WHERE status = 'reconnecting' AND updated_at < unixepoch() - ?`
+    )
+    .run(thresholdSeconds).changes;
+}
+
+// --- Container queries ---
+
+export function insertContainer(
+  id: string,
+  nodeId: string,
+  dockerId: string,
+  image: string,
+  vncPort: number
+): void {
+  getDb()
+    .prepare(
+      `INSERT INTO containers (id, node_id, docker_id, image, vnc_port) VALUES (?, ?, ?, ?, ?)`
+    )
+    .run(id, nodeId, dockerId, image, vncPort);
+}
+
+export function updateContainerDocker(id: string, dockerId: string, vncPort: number): void {
+  getDb()
+    .prepare(
+      `UPDATE containers SET docker_id = ?, vnc_port = ?, status = 'running', updated_at = unixepoch() WHERE id = ?`
+    )
+    .run(dockerId, vncPort, id);
+}
+
+export function removeContainer(id: string): void {
+  getDb().prepare(`DELETE FROM sessions WHERE container_id = ?`).run(id);
+  getDb().prepare(`DELETE FROM containers WHERE id = ?`).run(id);
+}
+
+export function getContainersByNode(nodeId: string): any[] {
+  return getDb()
+    .prepare(`SELECT * FROM containers WHERE node_id = ? ORDER BY created_at`)
+    .all(nodeId);
+}
+
+export function getContainer(id: string): any {
+  return getDb().prepare(`SELECT * FROM containers WHERE id = ?`).get(id);
+}
+
+export function countContainersByNode(nodeId: string): number {
+  const row = getDb()
+    .prepare(`SELECT COUNT(*) as count FROM containers WHERE node_id = ? AND status = 'running'`)
+    .get(nodeId) as any;
+  return row.count;
+}
+
+// --- Session queries ---
+
+export function insertSession(id: string, containerId: string, command: string): void {
+  getDb()
+    .prepare(`INSERT INTO sessions (id, container_id, command) VALUES (?, ?, ?)`)
+    .run(id, containerId, command);
+}
+
+export function markSessionExited(id: string, exitCode: number): void {
+  getDb()
+    .prepare(
+      `UPDATE sessions SET status = 'exited', exit_code = ?, updated_at = unixepoch() WHERE id = ?`
+    )
+    .run(exitCode, id);
+}
+
+export function removeSession(id: string): void {
+  getDb().prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
+}
+
+export function getSessionsByContainer(containerId: string): any[] {
+  return getDb()
+    .prepare(`SELECT * FROM sessions WHERE container_id = ? ORDER BY created_at`)
+    .all(containerId);
+}
+
+export function getSession(id: string): any {
+  return getDb().prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+}
+
+export function countSessionsByContainer(containerId: string): number {
+  const row = getDb()
+    .prepare(
+      `SELECT COUNT(*) as count FROM sessions WHERE container_id = ? AND status = 'running'`
+    )
+    .get(containerId) as any;
+  return row.count;
+}
+
+export function updateScrollback(id: string, scrollback: string): void {
+  getDb()
+    .prepare(`UPDATE sessions SET scrollback = ?, updated_at = unixepoch() WHERE id = ?`)
+    .run(scrollback, id);
+}
+
+export function updateSessionInteractive(id: string, interactive: boolean): void {
+  getDb()
+    .prepare(`UPDATE sessions SET interactive = ?, updated_at = unixepoch() WHERE id = ?`)
+    .run(interactive ? 1 : 0, id);
+}
+
+// --- Full state (for UI snapshot) ---
+
+export function getFullState(): {
+  nodes: any[];
+  containers: any[];
+  sessions: any[];
+} {
+  return {
+    nodes: getDb().prepare(`SELECT * FROM nodes ORDER BY created_at`).all(),
+    containers: getDb().prepare(`SELECT * FROM containers ORDER BY created_at`).all(),
+    sessions: getDb()
+      .prepare(`SELECT id, container_id, command, status, exit_code, interactive, created_at, updated_at FROM sessions ORDER BY created_at`)
+      .all(),
+  };
+}

package/manager/src/server/index.ts

@@ -0,0 +1,85 @@
+import express from "express";
+import { createServer } from "http";
+import { createServer as createViteServer } from "vite";
+import path from "path";
+import { fileURLToPath } from "url";
+import { authMiddleware, getToken, validateToken } from "./auth.js";
+import { ensureThumbnailDir, getThumbnailPath } from "./thumbnails.js";
+import { markReconnectingNodes, markStaleReconnectingOffline, getStaleNodes, markNodeStatus } from "./db.js";
+import { setupWorkerWs } from "./ws/worker.js";
+import { setupUiWs } from "./ws/ui.js";
+import { setupSessionWs, startScrollbackFlush } from "./ws/session.js";
+import { setupVncWs } from "./ws/vnc.js";
+import nodesRouter from "./routes/nodes.js";
+import containersRouter from "./routes/containers.js";
+import sessionsRouter from "./routes/sessions.js";
+import statusRouter from "./routes/status.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PORT = parseInt(process.env.PORT ?? "5174", 10);
+
+async function main() {
+  ensureThumbnailDir();
+  markReconnectingNodes();
+  const app = express();
+  app.use(express.json());
+
+  app.get("/api/containers/:id/thumbnail", (req, res) => {
+    const token = (req.query.token as string) ?? req.headers.authorization?.slice(7);
+    if (!token || !validateToken(token)) { res.status(403).json({ error: "Invalid token" }); return; }
+    const thumbPath = getThumbnailPath(req.params.id);
+    if (!thumbPath) { res.status(404).json({ error: "No thumbnail" }); return; }
+    res.set("Cache-Control", "no-cache");
+    res.sendFile(thumbPath);
+  });
+
+  app.use("/api/nodes", authMiddleware, nodesRouter);
+  app.use("/api/containers", authMiddleware, containersRouter);
+  app.use("/api/sessions", authMiddleware, sessionsRouter);
+  app.use("/api/status", authMiddleware, statusRouter);
+
+  const httpServer = createServer(app);
+
+  const workerWss = setupWorkerWs();
+  const uiWss = setupUiWs();
+  const sessionWss = setupSessionWs();
+  const vncWss = setupVncWs();
+  startScrollbackFlush();
+
+  httpServer.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+    const p = url.pathname;
+    if (p === "/ws/worker") {
+      workerWss.handleUpgrade(req, socket, head, (ws) => workerWss.emit("connection", ws, req));
+    } else if (p === "/ws/ui") {
+      uiWss.handleUpgrade(req, socket, head, (ws) => uiWss.emit("connection", ws, req));
+    } else if (p.startsWith("/ws/session/")) {
+      sessionWss.handleUpgrade(req, socket, head, (ws) => sessionWss.emit("connection", ws, req));
+    } else if (p.startsWith("/ws/vnc/")) {
+      vncWss.handleUpgrade(req, socket, head, (ws) => vncWss.emit("connection", ws, req));
+    }
+    // else: let Vite HMR handle its own upgrades
+  });
+
+  const vite = await createViteServer({
+    configFile: path.join(__dirname, "../../vite.config.ts"),
+    server: {
+      middlewareMode: true,
+      hmr: { server: httpServer },
+    },
+  });
+  app.use(vite.middlewares);
+
+  setInterval(() => {
+    const stale = getStaleNodes(30);
+    for (const node of stale) { markNodeStatus(node.id, "offline"); }
+    markStaleReconnectingOffline(60);
+  }, 10_000);
+
+  httpServer.listen(PORT, () => {
+    console.log(`Swarm Manager running on http://localhost:${PORT}`);
+    console.log(`Token: ${getToken()}`);
+  });
+}
+
+main().catch(console.error);

package/manager/src/server/reconcile.ts

@@ -0,0 +1,58 @@
+import {
+  getContainersByNode,
+  getSessionsByContainer,
+  removeContainer,
+  updateContainerDocker,
+  markSessionExited,
+} from "./db.js";
+import { broadcastToUi } from "./ws/ui.js";
+import { deleteThumbnail } from "./thumbnails.js";
+
+interface WorkerContainer {
+  dockerId: string;
+  containerId?: string;
+  image: string;
+  status: string;
+  vncPort: number;
+  sessions: Array<{ pid: number; sessionId?: string; command: string }>;
+}
+
+export function reconcileWorkerState(
+  nodeId: string,
+  reportedContainers: WorkerContainer[]
+): void {
+  const dbContainers = getContainersByNode(nodeId);
+  const reportedDockerIds = new Set(reportedContainers.map((c) => c.dockerId));
+
+  // Remove DB containers no longer running on worker
+  for (const dbC of dbContainers) {
+    if (dbC.docker_id && !reportedDockerIds.has(dbC.docker_id)) {
+      removeContainer(dbC.id);
+      deleteThumbnail(dbC.id);
+      broadcastToUi({ type: "container-stopped", containerId: dbC.id });
+    }
+  }
+
+  // Reconcile sessions for each reported container
+  for (const reported of reportedContainers) {
+    const dbC = dbContainers.find(
+      (c: any) => c.id === reported.containerId || c.docker_id === reported.dockerId
+    );
+    if (!dbC) continue;
+
+    if (dbC.docker_id !== reported.dockerId || dbC.vnc_port !== reported.vncPort) {
+      updateContainerDocker(dbC.id, reported.dockerId, reported.vncPort);
+    }
+
+    const dbSessions = getSessionsByContainer(dbC.id);
+    for (const dbS of dbSessions) {
+      if (dbS.status === "running") {
+        const stillAlive = reported.sessions.some((s) => s.sessionId === dbS.id);
+        if (!stillAlive) {
+          markSessionExited(dbS.id, -1);
+          broadcastToUi({ type: "session-exited", sessionId: dbS.id, exitCode: -1 });
+        }
+      }
+    }
+  }
+}

package/manager/src/server/routes/containers.ts

@@ -0,0 +1,51 @@
+import { Router } from "express";
+import { v4 as uuid } from "uuid";
+import { getContainer, getNode, countContainersByNode, insertContainer, removeContainer, getSessionsByContainer } from "../db.js";
+import { sendToWorker } from "../ws/worker.js";
+import { saveThumbnail, deleteThumbnail } from "../thumbnails.js";
+
+const router = Router();
+
+router.post("/", (req, res) => {
+  const { nodeId, image = "swarm-base" } = req.body ?? {};
+  if (!nodeId) { res.status(400).json({ error: "nodeId is required" }); return; }
+  const node = getNode(nodeId);
+  if (!node || node.status !== "online") { res.status(400).json({ error: "Node not found or offline" }); return; }
+  const count = countContainersByNode(nodeId);
+  if (count >= node.max_containers) { res.status(409).json({ error: `Node at container limit (${node.max_containers})` }); return; }
+  const containerId = uuid();
+  insertContainer(containerId, nodeId, "", image, 0);
+  sendToWorker(nodeId, { type: "start-container", containerId, image });
+  res.status(201).json({ id: containerId, nodeId, image, status: "starting" });
+});
+
+router.delete("/:id", (req, res) => {
+  const container = getContainer(req.params.id);
+  if (!container) { res.status(404).json({ error: "Container not found" }); return; }
+  sendToWorker(container.node_id, { type: "stop-container", containerId: container.id });
+  removeContainer(container.id);
+  deleteThumbnail(container.id);
+  res.json({ ok: true });
+});
+
+router.get("/:id/sessions", (req, res) => {
+  const container = getContainer(req.params.id);
+  if (!container) { res.status(404).json({ error: "Container not found" }); return; }
+  res.json(getSessionsByContainer(req.params.id));
+});
+
+router.post("/:id/thumbnail", (req, res) => {
+  const container = getContainer(req.params.id);
+  if (!container) { res.status(404).json({ error: "Container not found" }); return; }
+  const { data } = req.body ?? {};
+  if (!data || typeof data !== "string") { res.status(400).json({ error: "data (base64) is required" }); return; }
+  try {
+    saveThumbnail(container.id, data);
+    res.json({ ok: true });
+  } catch (e: any) {
+    if (e.message === "Thumbnail too large") { res.status(413).json({ error: "Thumbnail exceeds 50KB" }); return; }
+    throw e;
+  }
+});
+
+export default router;

package/manager/src/server/routes/nodes.ts

@@ -0,0 +1,39 @@
+import { Router } from "express";
+import { getAllNodes, getNode, getContainersByNode, getSessionsByContainer, removeNode } from "../db.js";
+import { broadcastToUi } from "../ws/ui.js";
+import { sendToWorker } from "../ws/worker.js";
+
+const router = Router();
+
+router.get("/", (_req, res) => {
+  res.json(getAllNodes());
+});
+
+router.get("/:id", (req, res) => {
+  const node = getNode(req.params.id);
+  if (!node) { res.status(404).json({ error: "Node not found" }); return; }
+  const containers = getContainersByNode(node.id).map((c: any) => ({
+    ...c, sessions: getSessionsByContainer(c.id),
+  }));
+  res.json({ ...node, containers });
+});
+
+router.get("/:id/containers", (req, res) => {
+  const node = getNode(req.params.id);
+  if (!node) { res.status(404).json({ error: "Node not found" }); return; }
+  res.json(getContainersByNode(req.params.id));
+});
+
+router.delete("/:id", (req, res) => {
+  const node = getNode(req.params.id);
+  if (!node) { res.status(404).json({ error: "Node not found" }); return; }
+  const containers = getContainersByNode(node.id);
+  for (const c of containers) {
+    sendToWorker(node.id, { type: "stop-container", containerId: c.id });
+  }
+  removeNode(node.id);
+  broadcastToUi({ type: "node-deleted", nodeId: node.id });
+  res.json({ ok: true });
+});
+
+export default router;

package/manager/src/server/routes/sessions.ts

@@ -0,0 +1,56 @@
+import { Router } from "express";
+import { v4 as uuid } from "uuid";
+import { getSession, getContainer, countSessionsByContainer, insertSession, removeSession, updateSessionInteractive } from "../db.js";
+import { sendToWorker } from "../ws/worker.js";
+import { getScrollbackBuffer } from "../ws/session.js";
+import { broadcastToUi } from "../ws/ui.js";
+
+const router = Router();
+
+router.post("/", (req, res) => {
+  const { containerId, command = "bash" } = req.body ?? {};
+  if (!containerId) { res.status(400).json({ error: "containerId is required" }); return; }
+  const container = getContainer(containerId);
+  if (!container || container.status !== "running") { res.status(400).json({ error: "Container not found or not running" }); return; }
+  const count = countSessionsByContainer(containerId);
+  if (count >= container.max_sessions) { res.status(409).json({ error: `Container at session limit (${container.max_sessions})` }); return; }
+  const sessionId = uuid();
+  insertSession(sessionId, containerId, command);
+  sendToWorker(container.node_id, { type: "spawn-session", containerId: container.id, sessionId, command });
+  res.status(201).json({ id: sessionId, containerId, command, status: "starting" });
+});
+
+router.post("/:id/input", (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session || session.status !== "running") { res.status(404).json({ error: "Session not found or not running" }); return; }
+  const container = getContainer(session.container_id);
+  if (!container) { res.status(404).json({ error: "Container not found" }); return; }
+  sendToWorker(container.node_id, { type: "session-input", sessionId: session.id, data: req.body.data });
+  res.json({ ok: true });
+});
+
+router.get("/:id/output", (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) { res.status(404).json({ error: "Session not found" }); return; }
+  const buffer = getScrollbackBuffer(req.params.id);
+  res.json({ id: session.id, output: buffer ?? session.scrollback ?? "" });
+});
+
+router.patch("/:id", (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) { res.status(404).json({ error: "Session not found" }); return; }
+  if (req.body.interactive !== undefined) { updateSessionInteractive(req.params.id, req.body.interactive); }
+  res.json({ ok: true });
+});
+
+router.delete("/:id", (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) { res.status(404).json({ error: "Session not found" }); return; }
+  const container = getContainer(session.container_id);
+  if (container) { sendToWorker(container.node_id, { type: "kill-session", sessionId: session.id }); }
+  removeSession(session.id);
+  broadcastToUi({ type: "session-deleted", sessionId: session.id });
+  res.json({ ok: true });
+});
+
+export default router;

package/manager/src/server/routes/status.ts

@@ -0,0 +1,18 @@
+import { Router } from "express";
+import { getDb } from "../db.js";
+
+const router = Router();
+
+router.get("/", (_req, res) => {
+  const db = getDb();
+  const nodes = db.prepare(`SELECT status, COUNT(*) as count FROM nodes GROUP BY status`).all() as any[];
+  const containers = db.prepare(`SELECT status, COUNT(*) as count FROM containers GROUP BY status`).all() as any[];
+  const sessions = db.prepare(`SELECT status, COUNT(*) as count FROM sessions GROUP BY status`).all() as any[];
+  res.json({
+    nodes: Object.fromEntries(nodes.map((r: any) => [r.status, r.count])),
+    containers: Object.fromEntries(containers.map((r: any) => [r.status, r.count])),
+    sessions: Object.fromEntries(sessions.map((r: any) => [r.status, r.count])),
+  });
+});
+
+export default router;

package/manager/src/server/thumbnails.ts

@@ -0,0 +1,26 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const THUMB_DIR = path.join(__dirname, "../../data/thumbnails");
+
+export function ensureThumbnailDir(): void {
+  fs.mkdirSync(THUMB_DIR, { recursive: true });
+}
+
+export function saveThumbnail(containerId: string, base64Data: string): void {
+  const buf = Buffer.from(base64Data, "base64");
+  if (buf.length > 50 * 1024) throw new Error("Thumbnail too large");
+  fs.writeFileSync(path.join(THUMB_DIR, `${containerId}.jpg`), buf);
+}
+
+export function getThumbnailPath(containerId: string): string | null {
+  const p = path.join(THUMB_DIR, `${containerId}.jpg`);
+  return fs.existsSync(p) ? p : null;
+}
+
+export function deleteThumbnail(containerId: string): void {
+  const p = path.join(THUMB_DIR, `${containerId}.jpg`);
+  try { fs.unlinkSync(p); } catch {}
+}