@cryptiklemur/lattice 4.0.2 → 5.0.0

package/dist/server/assets.js

@@ -0,0 +1,39 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+var __dirname_local = dirname(fileURLToPath(import.meta.url));
+var CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".webmanifest": "application/manifest+json",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".txt": "text/plain",
+    ".map": "application/json",
+    ".wasm": "application/wasm",
+};
+export async function initAssets() {
+    // No-op in npm mode — static serving is handled by Express
+}
+export function serveStaticAsset(_pathname) {
+    return null;
+}
+export function hasEmbeddedAssets() {
+    return false;
+}
+export function getClientDir() {
+    var distPath = join(__dirname_local, "../../dist/client");
+    if (existsSync(distPath))
+        return distPath;
+    return join(__dirname_local, "../../dist/client");
+}
+export function guessContentType(path) {
+    var ext = path.slice(path.lastIndexOf("."));
+    return CONTENT_TYPES[ext] || "application/octet-stream";
+}

package/dist/server/auth/passphrase.js

@@ -0,0 +1,70 @@
+import { scrypt, randomBytes, timingSafeEqual } from "node:crypto";
+function scryptAsync(password, salt, keylen) {
+    return new Promise(function (resolve, reject) {
+        scrypt(password, salt, keylen, function (err, derivedKey) {
+            if (err)
+                reject(err);
+            else
+                resolve(derivedKey);
+        });
+    });
+}
+var TOKEN_TTL = 86400000;
+var CLEANUP_INTERVAL = 600000;
+var activeSessions = new Map();
+export async function hashPassphrase(passphrase) {
+    var salt = randomBytes(16).toString("hex");
+    var hash = (await scryptAsync(passphrase, salt, 64)).toString("hex");
+    return salt + ":" + hash;
+}
+export async function verifyPassphrase(passphrase, storedHash) {
+    var parts = storedHash.split(":");
+    if (parts.length !== 2) {
+        return false;
+    }
+    var salt = parts[0];
+    var hash = parts[1];
+    try {
+        var derived = await scryptAsync(passphrase, salt, 64);
+        var expected = Buffer.from(hash, "hex");
+        if (derived.length !== expected.length) {
+            return false;
+        }
+        return timingSafeEqual(derived, expected);
+    }
+    catch {
+        return false;
+    }
+}
+export function generateSessionToken() {
+    return randomBytes(32).toString("hex");
+}
+export function addSession(token) {
+    activeSessions.set(token, Date.now());
+}
+export function removeSession(token) {
+    activeSessions.delete(token);
+}
+export function isValidSession(token) {
+    var createdAt = activeSessions.get(token);
+    if (createdAt === undefined) {
+        return false;
+    }
+    if (Date.now() - createdAt > TOKEN_TTL) {
+        activeSessions.delete(token);
+        return false;
+    }
+    return true;
+}
+export function clearSessions() {
+    activeSessions.clear();
+}
+var cleanupInterval = setInterval(function () {
+    var now = Date.now();
+    activeSessions.forEach(function (createdAt, token) {
+        if (now - createdAt > TOKEN_TTL) {
+            activeSessions.delete(token);
+        }
+    });
+}, CLEANUP_INTERVAL);
+cleanupInterval.unref();

package/dist/server/config.js

@@ -0,0 +1,47 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_PORT, LATTICE_HOME_DIR } from "#shared";
+var home = process.env.LATTICE_HOME || join(homedir(), LATTICE_HOME_DIR);
+var cachedConfig = null;
+export function getLatticeHome() {
+    if (!existsSync(home)) {
+        mkdirSync(home, { recursive: true });
+    }
+    return home;
+}
+export function getConfigPath() {
+    return join(getLatticeHome(), "config.json");
+}
+export function loadConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    var configPath = getConfigPath();
+    if (!existsSync(configPath)) {
+        return createDefaultConfig();
+    }
+    var raw = readFileSync(configPath, "utf-8");
+    cachedConfig = JSON.parse(raw);
+    return cachedConfig;
+}
+export function saveConfig(config) {
+    var configPath = getConfigPath();
+    writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    cachedConfig = config;
+}
+export function invalidateConfigCache() {
+    cachedConfig = null;
+}
+function createDefaultConfig() {
+    var config = {
+        port: DEFAULT_PORT,
+        name: hostname(),
+        tls: false,
+        debug: false,
+        globalEnv: {},
+        projects: [],
+    };
+    saveConfig(config);
+    return config;
+}

package/dist/server/daemon.js

@@ -0,0 +1,535 @@
+import { join, resolve } from "node:path";
+import { createServer as createHttpServer } from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+import { readFileSync, existsSync, createReadStream, statSync } from "node:fs";
+import express from "express";
+import { WebSocketServer } from "ws";
+import { getClientDir } from "./assets.js";
+import { getLatticeHome, loadConfig } from "./config.js";
+import { loadOrCreateIdentity } from "./identity.js";
+import { addClient, removeClient, routeMessage } from "./ws/server.js";
+import { broadcast, sendTo } from "./ws/broadcast.js";
+import { buildNodesMessage } from "./handlers/mesh.js";
+import { startDiscovery } from "./mesh/discovery.js";
+import { startMeshConnections, onPeerConnected, onPeerDisconnected, onPeerMessage, getAllRemoteProjects } from "./mesh/connector.js";
+import { handleProxyRequest, handleProxyResponse } from "./mesh/proxy.js";
+import { verifyPassphrase, generateSessionToken, addSession, isValidSession } from "./auth/passphrase.js";
+import { ensureCerts } from "./tls.js";
+import { log } from "./logger.js";
+import { detectIdeProjectName } from "./handlers/settings.js";
+import "./handlers/session";
+import "./handlers/chat";
+import "./handlers/attachment";
+import { loadInterruptedSessions, cleanupClientPermissions, cleanupClientElicitations, getActiveStreamCountForProject } from "./project/sdk-bridge.js";
+import { runWarmup, isWarmupComplete, getWarmupModels, getWarmupAccountInfo, getWarmupRateLimits } from "./project/warmup.js";
+import { clearActiveSession } from "./handlers/chat.js";
+import { clearActiveProject } from "./handlers/fs.js";
+import { clearClientRemoteNode } from "./ws/router.js";
+import "./handlers/fs";
+import "./handlers/terminal";
+import "./handlers/settings";
+import "./handlers/project-settings";
+import "./handlers/mesh";
+import "./handlers/loop";
+import "./handlers/scheduler";
+import "./handlers/notes";
+import "./handlers/skills";
+import "./handlers/memory";
+import "./handlers/editor";
+import "./handlers/analytics";
+import "./handlers/bookmarks";
+import "./handlers/plugins";
+import "./handlers/update";
+import "./handlers/themes";
+import { startScheduler } from "./features/scheduler.js";
+import { loadNotes } from "./features/sticky-notes.js";
+import { startPeriodicUpdateCheck, getCachedUpdateInfo } from "./update-checker.js";
+import { loadBookmarks } from "./project/bookmarks.js";
+import { cleanupClientTerminals } from "./handlers/terminal.js";
+import { cleanupClient as cleanupClientAttachments } from "./handlers/attachment.js";
+import { initPush, getVapidPublicKey, addPushSubscription } from "./push.js";
+var RATE_LIMIT_WINDOW = 10000;
+var RATE_LIMIT_MAX = 100;
+var clientRateLimits = new Map();
+var wsClientIds = new WeakMap();
+function parseCookies(cookieHeader) {
+    var map = new Map();
+    var parts = cookieHeader.split(";");
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i].trim();
+        var eqIdx = part.indexOf("=");
+        if (eqIdx === -1) {
+            continue;
+        }
+        var key = part.slice(0, eqIdx).trim();
+        var value = part.slice(eqIdx + 1).trim();
+        map.set(key, value);
+    }
+    return map;
+}
+function isAuthenticatedReq(req, passphraseHash) {
+    if (!passphraseHash) {
+        return true;
+    }
+    var cookieHeader = req.headers.cookie || "";
+    var cookies = parseCookies(cookieHeader);
+    var token = cookies.get("lattice_auth");
+    if (!token) {
+        return false;
+    }
+    return isValidSession(token);
+}
+function buildLoginPage() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Lattice — Authenticate</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: 'Courier New', monospace;
+      background: #0d0d0d;
+      color: #e0e0e0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .card {
+      background: #161616;
+      border: 1px solid #2a2a2a;
+      border-radius: 6px;
+      padding: 2.5rem;
+      width: 100%;
+      max-width: 360px;
+    }
+    h1 {
+      font-size: 1.1rem;
+      font-weight: 600;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      color: #a0a0a0;
+      margin-bottom: 1.75rem;
+    }
+    label {
+      display: block;
+      font-size: 0.72rem;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: #606060;
+      margin-bottom: 0.4rem;
+    }
+    input[type="password"] {
+      width: 100%;
+      background: #0d0d0d;
+      border: 1px solid #2a2a2a;
+      border-radius: 4px;
+      color: #e0e0e0;
+      font-family: inherit;
+      font-size: 0.9rem;
+      padding: 0.6rem 0.75rem;
+      outline: none;
+      transition: border-color 0.15s;
+    }
+    input[type="password"]:focus { border-color: #4a4a4a; }
+    button {
+      width: 100%;
+      margin-top: 1.25rem;
+      background: #e0e0e0;
+      color: #0d0d0d;
+      border: none;
+      border-radius: 4px;
+      font-family: inherit;
+      font-size: 0.85rem;
+      font-weight: 700;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      padding: 0.65rem;
+      cursor: pointer;
+      transition: background 0.15s;
+    }
+    button:hover { background: #c0c0c0; }
+    .error {
+      margin-top: 0.85rem;
+      font-size: 0.78rem;
+      color: #c07070;
+      text-align: center;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>Lattice</h1>
+    <form id="form">
+      <label for="passphrase">Passphrase</label>
+      <input type="password" id="passphrase" name="passphrase" autofocus autocomplete="current-password" />
+      <button type="submit">Authenticate</button>
+      <div class="error" id="error"></div>
+    </form>
+  </div>
+  <script>
+    document.getElementById('form').addEventListener('submit', async function(e) {
+      e.preventDefault();
+      var passphrase = document.getElementById('passphrase').value;
+      try {
+        var res = await fetch('/auth', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ passphrase: passphrase })
+        });
+        if (res.ok) {
+          window.location.reload();
+        } else {
+          document.getElementById('error').textContent = 'Invalid passphrase.';
+        }
+      } catch {
+        document.getElementById('error').textContent = 'Connection error.';
+      }
+    });
+  </script>
+</body>
+</html>`;
+}
+function getMimeType(filePath) {
+    var ext = filePath.split(".").pop() || "";
+    var mimeTypes = {
+        html: "text/html; charset=utf-8",
+        js: "application/javascript",
+        css: "text/css",
+        json: "application/json",
+        svg: "image/svg+xml",
+        png: "image/png",
+        ico: "image/x-icon",
+        webmanifest: "application/manifest+json",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ttf: "font/ttf",
+        txt: "text/plain",
+        map: "application/json",
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+}
+function handleWsOpen(ws, clientId) {
+    wsClientIds.set(ws, clientId);
+    addClient(clientId, ws);
+    log.ws("Client connected: %s", clientId);
+    sendTo(clientId, { type: "mesh:nodes", nodes: buildNodesMessage() });
+    var connectConfig = loadConfig();
+    var connectIdentity = loadOrCreateIdentity();
+    var localProjects = connectConfig.projects.map(function (p) {
+        return { slug: p.slug, path: p.path, title: p.title, nodeId: connectIdentity.id, nodeName: connectConfig.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path), activeSessions: getActiveStreamCountForProject(p.slug) };
+    });
+    var connectRemoteProjects = getAllRemoteProjects(connectIdentity.id);
+    sendTo(clientId, {
+        type: "projects:list",
+        projects: localProjects.concat(connectRemoteProjects),
+    });
+    if (isWarmupComplete()) {
+        sendTo(clientId, { type: "warmup:models", models: getWarmupModels() });
+        var accountInfo = getWarmupAccountInfo();
+        if (accountInfo) {
+            sendTo(clientId, {
+                type: "warmup:account",
+                email: accountInfo.email,
+                organization: accountInfo.organization,
+                subscriptionType: accountInfo.subscriptionType,
+                apiKeySource: accountInfo.apiKeySource,
+                apiProvider: accountInfo.apiProvider,
+            });
+        }
+        var cachedRateLimits = getWarmupRateLimits();
+        for (var rli = 0; rli < cachedRateLimits.length; rli++) {
+            var rl = cachedRateLimits[rli];
+            sendTo(clientId, {
+                type: "chat:rate_limit",
+                status: rl.status,
+                utilization: rl.utilization,
+                resetsAt: rl.resetsAt,
+                rateLimitType: rl.rateLimitType,
+                overageStatus: rl.overageStatus,
+                overageResetsAt: rl.overageResetsAt,
+                isUsingOverage: rl.isUsingOverage,
+            });
+        }
+    }
+    void (async function () {
+        var { listSessions } = await import("./project/session.js");
+        for (var pi = 0; pi < connectConfig.projects.length; pi++) {
+            try {
+                var result = await listSessions(connectConfig.projects[pi].slug, { limit: 40 });
+                sendTo(clientId, {
+                    type: "session:list",
+                    projectSlug: connectConfig.projects[pi].slug,
+                    sessions: result.sessions,
+                    totalCount: result.totalCount,
+                });
+            }
+            catch { }
+        }
+    })();
+}
+function handleWsMessage(ws, data) {
+    var clientId = wsClientIds.get(ws);
+    if (!clientId)
+        return;
+    var now = Date.now();
+    var limit = clientRateLimits.get(clientId);
+    if (!limit || now - limit.windowStart > RATE_LIMIT_WINDOW) {
+        limit = { count: 0, windowStart: now };
+        clientRateLimits.set(clientId, limit);
+    }
+    limit.count++;
+    if (limit.count > RATE_LIMIT_MAX) {
+        sendTo(clientId, { type: "chat:error", message: "Rate limit exceeded, please slow down" });
+        return;
+    }
+    var text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString() : Buffer.from(data).toString();
+    try {
+        var msg = JSON.parse(text);
+        routeMessage(clientId, msg);
+    }
+    catch (err) {
+        log.ws("Invalid JSON message: %O", err);
+    }
+}
+function handleWsClose(ws) {
+    var clientId = wsClientIds.get(ws);
+    if (!clientId)
+        return;
+    clearActiveSession(clientId);
+    clearActiveProject(clientId);
+    clearClientRemoteNode(clientId);
+    removeClient(clientId);
+    cleanupClientTerminals(clientId);
+    cleanupClientAttachments(clientId);
+    cleanupClientPermissions(clientId);
+    cleanupClientElicitations(clientId);
+    clientRateLimits.delete(clientId);
+    wsClientIds.delete(ws);
+    log.ws("Client disconnected: %s", clientId);
+}
+export async function startDaemon(portOverride) {
+    var config = loadConfig();
+    if (portOverride && !isNaN(portOverride)) {
+        config.port = portOverride;
+    }
+    var identity = loadOrCreateIdentity();
+    log.server("Node: %s (%s)", config.name, identity.id);
+    log.server("Home: %s", getLatticeHome());
+    var clientDir = getClientDir();
+    var app = express();
+    app.use(express.json());
+    var authAttempts = new Map();
+    var AUTH_RATE_LIMIT = 5;
+    var AUTH_RATE_WINDOW = 60000;
+    app.post("/auth", async function (req, res) {
+        var ip = req.ip || req.socket.remoteAddress || "unknown";
+        var now = Date.now();
+        var attempts = authAttempts.get(ip) || [];
+        attempts = attempts.filter(function (t) { return now - t < AUTH_RATE_WINDOW; });
+        if (attempts.length >= AUTH_RATE_LIMIT) {
+            res.status(429).json({ ok: false, error: "Too many attempts. Try again later." });
+            return;
+        }
+        attempts.push(now);
+        authAttempts.set(ip, attempts);
+        var passphrase = req.body.passphrase || "";
+        if (!config.passphraseHash || await verifyPassphrase(passphrase, config.passphraseHash)) {
+            var token = generateSessionToken();
+            addSession(token);
+            res.setHeader("Set-Cookie", "lattice_auth=" + token + "; HttpOnly; Path=/; SameSite=Strict");
+            res.json({ ok: true });
+        }
+        else {
+            res.status(401).json({ ok: false });
+        }
+    });
+    app.use(function (req, res, next) {
+        if (req.path === "/ws" || req.path === "/auth") {
+            next();
+            return;
+        }
+        if (!isAuthenticatedReq(req, config.passphraseHash)) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(buildLoginPage());
+            return;
+        }
+        next();
+    });
+    app.get("/api/vapid-public-key", function (_req, res) {
+        res.json({ publicKey: getVapidPublicKey() });
+    });
+    app.post("/api/push-subscribe", function (req, res) {
+        try {
+            var pushBody = req.body;
+            addPushSubscription(pushBody);
+            res.json({ ok: true });
+        }
+        catch {
+            res.status(400).json({ ok: false });
+        }
+    });
+    app.get("/api/file", function (req, res) {
+        var reqFilePath = req.query.path;
+        if (!reqFilePath) {
+            res.status(400).send("Missing path parameter");
+            return;
+        }
+        var resolved = null;
+        for (var pi = 0; pi < config.projects.length; pi++) {
+            var projectPath = resolve(config.projects[pi].path);
+            var candidate = resolve(projectPath, reqFilePath);
+            if (candidate.startsWith(projectPath + "/") && existsSync(candidate)) {
+                resolved = candidate;
+                break;
+            }
+        }
+        if (!resolved) {
+            res.status(404).send("File not found");
+            return;
+        }
+        var stat = statSync(resolved);
+        res.setHeader("Content-Type", getMimeType(resolved));
+        res.setHeader("Content-Length", stat.size);
+        createReadStream(resolved).pipe(res);
+    });
+    var tlsOptions;
+    if (config.tls) {
+        try {
+            var certs = ensureCerts();
+            tlsOptions = {
+                cert: readFileSync(certs.cert),
+                key: readFileSync(certs.key),
+            };
+            log.server("TLS enabled");
+        }
+        catch (err) {
+            console.error("[lattice] Failed to load TLS certs, falling back to HTTP:", err);
+        }
+    }
+    var protocol = tlsOptions ? "https" : "http";
+    var httpServer = tlsOptions
+        ? createHttpsServer(tlsOptions, app)
+        : createHttpServer(app);
+    var isDev = process.env.NODE_ENV !== "production";
+    if (isDev) {
+        var { createServer: createViteServer } = await import("vite");
+        var vite = await createViteServer({
+            server: {
+                middlewareMode: true,
+                hmr: { server: httpServer },
+            },
+            appType: "spa",
+        });
+        app.use(vite.middlewares);
+        log.server("Vite dev server attached (middleware mode, HMR on same port)");
+    }
+    else if (clientDir && existsSync(clientDir)) {
+        app.use(express.static(clientDir));
+        app.get("/{*path}", function (_req, res) {
+            var indexPath = join(clientDir, "index.html");
+            if (existsSync(indexPath)) {
+                res.sendFile(indexPath);
+            }
+            else {
+                res.status(404).send("Not found");
+            }
+        });
+    }
+    var wss = new WebSocketServer({ noServer: true });
+    httpServer.on("upgrade", function (req, socket, head) {
+        var url = new URL(req.url || "/", "http://localhost");
+        if (url.pathname !== "/ws") {
+            return;
+        }
+        if (!isAuthenticatedReq(req, config.passphraseHash)) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, function (ws) {
+            var clientId = crypto.randomUUID();
+            handleWsOpen(ws, clientId);
+            ws.on("message", function (data) { handleWsMessage(ws, data); });
+            ws.on("close", function () { handleWsClose(ws); });
+        });
+    });
+    var maxRetries = 10;
+    for (var attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await new Promise(function (resolveP, reject) {
+                httpServer.once("error", function (err) {
+                    if (err.code === "EADDRINUSE" && attempt < maxRetries - 1) {
+                        log.server("Port %d in use, retrying in 1s (%d/%d)...", config.port, attempt + 1, maxRetries);
+                        setTimeout(function () { resolveP(); }, 1000);
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                httpServer.listen(config.port, "0.0.0.0", function () {
+                    resolveP();
+                });
+            });
+            if (httpServer.listening)
+                break;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    log.server("Listening on %s://0.0.0.0:%d", protocol, config.port);
+    startDiscovery(identity.id, config.name, config.port);
+    startMeshConnections();
+    startScheduler();
+    loadNotes();
+    loadBookmarks();
+    startPeriodicUpdateCheck();
+    loadInterruptedSessions();
+    initPush();
+    var firstProject = config.projects[0];
+    if (firstProject) {
+        void runWarmup(firstProject.path);
+    }
+    onPeerConnected(function (nodeId) {
+        broadcast({ type: "mesh:node_online", nodeId: nodeId });
+    });
+    onPeerDisconnected(function (nodeId) {
+        broadcast({ type: "mesh:node_offline", nodeId: nodeId });
+    });
+    onPeerMessage(function (nodeId, msg) {
+        if (msg.type === "mesh:proxy_request") {
+            handleProxyRequest(nodeId, msg);
+            return;
+        }
+        if (msg.type === "mesh:proxy_response") {
+            handleProxyResponse(msg);
+            return;
+        }
+    });
+    setInterval(function () {
+        var currentConfig = loadConfig();
+        var currentIdentity = loadOrCreateIdentity();
+        broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        var localProjects = currentConfig.projects.map(function (p) {
+            return { slug: p.slug, path: p.path, title: p.title, nodeId: currentIdentity.id, nodeName: currentConfig.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path), activeSessions: getActiveStreamCountForProject(p.slug) };
+        });
+        var remoteProjects = getAllRemoteProjects(currentIdentity.id);
+        broadcast({
+            type: "projects:list",
+            projects: localProjects.concat(remoteProjects),
+        });
+        var updateInfo = getCachedUpdateInfo();
+        if (updateInfo && updateInfo.updateAvailable) {
+            broadcast({
+                type: "update:status",
+                currentVersion: updateInfo.currentVersion,
+                latestVersion: updateInfo.latestVersion,
+                updateAvailable: updateInfo.updateAvailable,
+                releaseUrl: updateInfo.releaseUrl,
+                installMode: updateInfo.installMode,
+            });
+        }
+    }, 10000);
+}