${oauthError || "no code"}
`); } try { const resp = await fetch("https://open.tiktokapis.com/v2/oauth/token/", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_key: TIKTOK_CLIENT_KEY, client_secret: TIKTOK_CLIENT_SECRET, code, grant_type: "authorization_code", redirect_uri: TIKTOK_REDIRECT_URI, }), }); const data = await resp.json(); if (!data.access_token) { log("error", `tiktok oauth token exchange failed: ${JSON.stringify(data)}`); return res.send(`${JSON.stringify(data, null, 2)}`);
}
// Fetch username
let username = "";
try {
const userResp = await fetch("https://open.tiktokapis.com/v2/user/info/?fields=username,display_name", {
headers: { Authorization: `Bearer ${data.access_token}` },
});
const userData = await userResp.json();
username = userData.data?.user?.username || userData.data?.user?.display_name || "";
} catch {}
tiktokToken = {
access_token: data.access_token,
refresh_token: data.refresh_token,
open_id: data.open_id,
expires_at: Date.now() + data.expires_in * 1000,
refresh_expires_at: data.refresh_expires_in ? Date.now() + data.refresh_expires_in * 1000 : null,
scope: data.scope,
username,
};
tiktokLastUsed = Date.now();
await saveTiktokSession(tiktokToken);
log("info", `tiktok connected for @${username || data.open_id}`);
return res.send(`${err.message}
`); } }); app.use("/api", requireAdmin); app.get("/health", async (req, res) => { const mongoOk = db ? await db.admin().ping().then(() => true).catch(() => false) : false; res.json({ status: "ok", uptime: Date.now() - SERVER_START_TIME, mongo: mongoOk }); }); app.get("/api/overview", async (req, res) => { log("info", "overview requested"); const [collections, storage, redis, dbSize] = await Promise.all([ getDbStats(), getStorageStats(), getRedisStats(), getDbSize(db), ]); const find = (name) => collections?.find((c) => c.name === name)?.count || 0; res.json({ db: { users: find("users"), handles: find("@handles"), paintings: find("paintings"), pieces: find("pieces"), kidlisp: find("kidlisp"), moods: find("moods"), chatSystem: find("chat-system"), chatClock: find("chat-clock"), verifications: find("verifications"), totalCollections: collections?.length || 0, totalDocuments: collections?.reduce((s, c) => s + c.count, 0) || 0, size: dbSize, }, storage: { buckets: storage, totalGB: storage.reduce((s, b) => s + parseFloat(b.gb), 0).toFixed(2), }, redis, uptime: Date.now() - SERVER_START_TIME, }); }); // 📡 Telemetry overview — GPU/KidLisp logs + boot logs stats app.get("/api/telemetry", async (req, res) => { if (!db) return res.status(503).json({ error: "no db" }); try { const [klStats, bootStats, klRecent] = await Promise.all([ db.collection("kidlisp-logs").aggregate([ { $facet: { total: [{ $count: "n" }], byType: [{ $group: { _id: "$type", count: { $sum: 1 } } }], byEffect: [{ $group: { _id: "$effect", count: { $sum: 1 } } }], byGpu: [{ $group: { _id: "$device.gpu.renderer", count: { $sum: 1 } } }], size: [{ $group: { _id: null, avgSize: { $avg: { $bsonSize: "$$ROOT" } } } }], }} ]).toArray(), db.collection("boots").aggregate([ { $facet: { total: [{ $count: "n" }], byStatus: [{ $group: { _id: "$status", count: { $sum: 1 } } }], }} ]).toArray(), db.collection("kidlisp-logs") .find() .sort({ createdAt: -1 }) .limit(20) .toArray(), ]); const kl = klStats[0] || {}; const bt = bootStats[0] || {}; const klTotal = kl.total?.[0]?.n || 0; const klAvgSize = kl.size?.[0]?.avgSize || 0; res.json({ kidlispLogs: { total: klTotal, estimatedSizeKB: Math.round((klTotal * klAvgSize) / 1024), byType: kl.byType || [], byEffect: kl.byEffect || [], byGpu: kl.byGpu || [], recent: klRecent, }, boots: { total: bt.total?.[0]?.n || 0, byStatus: bt.byStatus || [], }, }); } catch (err) { res.status(500).json({ error: err.message }); } }); // Purge kidlisp-logs from silo app.delete("/api/telemetry/kidlisp-logs", async (req, res) => { if (!db) return res.status(503).json({ error: "no db" }); try { const result = await db.collection("kidlisp-logs").deleteMany({}); log("info", `purged ${result.deletedCount} kidlisp-logs`); res.json({ ok: true, deleted: result.deletedCount }); } catch (err) { res.status(500).json({ error: err.message }); } }); app.get("/api/db/collections", async (req, res) => { log("info", "collections requested"); const stats = await getDbStats() || []; res.json({ collections: stats, categories: CATEGORY_META }); }); app.get("/api/db/backups", async (req, res) => { log("info", "backups requested"); const backups = []; // Check local filesystem for mongodump backups const backupPath = process.env.BACKUP_PATH || "/var/backups/mongodb"; try { if (fs.existsSync(backupPath)) { const entries = fs.readdirSync(backupPath, { withFileTypes: true }); for (const entry of entries) { try { const fullPath = backupPath + "/" + entry.name; const stat = fs.statSync(fullPath); let totalSize = stat.size; // For directories (mongodump output), sum up contents if (entry.isDirectory()) { totalSize = 0; const walk = (dir) => { for (const f of fs.readdirSync(dir, { withFileTypes: true })) { const fp = dir + "/" + f.name; if (f.isDirectory()) walk(fp); else totalSize += fs.statSync(fp).size; } }; walk(fullPath); } backups.push({ name: entry.name, source: "local", size: totalSize, date: stat.mtime.toISOString(), isDirectory: entry.isDirectory(), }); } catch {} } } } catch (err) { log("error", `backup scan (local): ${err.message}`); } // Check S3 for backups const backupBucket = process.env.BACKUP_BUCKET; const backupPrefix = process.env.BACKUP_PREFIX || "backups/"; if (backupBucket) { try { let continuationToken; do { const resp = await s3.send(new ListObjectsV2Command({ Bucket: backupBucket, Prefix: backupPrefix, ContinuationToken: continuationToken, })); if (resp.Contents) { for (const obj of resp.Contents) { const name = obj.Key.replace(backupPrefix, ""); if (!name) continue; backups.push({ name, source: "s3", bucket: backupBucket, size: obj.Size, date: obj.LastModified?.toISOString(), }); } } continuationToken = resp.IsTruncated ? resp.NextContinuationToken : undefined; } while (continuationToken); } catch (err) { log("error", `backup scan (s3): ${err.message}`); } } backups.sort((a, b) => new Date(b.date) - new Date(a.date)); res.json({ backups, backupPath, backupBucket: backupBucket || null }); }); app.get("/api/db/compare", async (req, res) => { log("info", "db compare requested"); const [primary, atlas, primarySize, atlasSize] = await Promise.all([ getDbStats(), getAtlasStats(), getDbSize(db), getDbSize(atlasDb), ]); const primaryHost = parseMongoHost(process.env.MONGODB_CONNECTION_STRING); const atlasHost = parseMongoHost(process.env.ATLAS_CONNECTION_STRING); // Silo is now the source of truth; Atlas is deprecated const activeDb = "silo"; const allNames = new Set([ ...(primary || []).map(c => c.name), ...(atlas || []).map(c => c.name), ]); const comparison = [...allNames].sort().map(name => { const p = primary?.find(c => c.name === name); const a = atlas?.find(c => c.name === name); return { name, primary: p?.count ?? null, atlas: a?.count ?? null, synced: p?.count === a?.count, }; }); const allSynced = comparison.every(c => c.synced); res.json({ primaryLabel: primaryHost, atlasLabel: atlasHost, activeDb, allSynced, primarySize, atlasSize, primaryConnected: !!db, atlasConnected: !!atlasDb, sameConnection: process.env.MONGODB_CONNECTION_STRING === process.env.ATLAS_CONNECTION_STRING, collections: comparison, }); }); // Sync: copy all collections from Atlas → primary let syncInProgress = false; app.post("/api/db/sync", async (req, res) => { if (syncInProgress) return res.status(409).json({ error: "Sync already in progress" }); if (!db || !atlasDb) return res.status(500).json({ error: "Both databases must be connected" }); if (atlasDb === db) return res.status(400).json({ error: "Primary and Atlas are the same connection" }); syncInProgress = true; log("info", "sync started: atlas -> primary"); try { const collections = await atlasDb.listCollections().toArray(); const results = []; for (const col of collections) { const name = col.name; const docs = await atlasDb.collection(name).find({}).toArray(); // Drop and re-insert await db.collection(name).deleteMany({}); if (docs.length > 0) { await db.collection(name).insertMany(docs); } results.push({ name, docs: docs.length }); log("info", `synced ${name}: ${docs.length} docs`); } // Invalidate cache cachedDbStats = null; dbStatsAge = 0; log("info", `sync complete: ${results.length} collections`); res.json({ ok: true, collections: results }); } catch (err) { log("error", `sync failed: ${err.message}`); res.status(500).json({ error: err.message }); } finally { syncInProgress = false; } }); app.get("/api/db/health", async (req, res) => { if (!db) return res.json({ connected: false }); try { const status = await db.admin().serverStatus(); res.json({ connected: true, version: status.version, uptime: status.uptime, connections: status.connections, opcounters: status.opcounters, }); } catch (err) { res.json({ connected: false, error: err.message }); } }); app.get("/api/redis", async (req, res) => { log("info", "redis stats requested"); res.json(await getRedisStats() || { connected: false }); }); app.get("/api/storage/buckets", async (req, res) => { log("info", "storage buckets requested"); res.json(await getStorageStats()); }); app.get("/api/services/oven", async (req, res) => { const url = process.env.OVEN_URL || "https://localhost:3002"; try { const start = Date.now(); const resp = await fetch(`${url}/health`, { signal: AbortSignal.timeout(5000) }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/session", async (req, res) => { const url = process.env.SESSION_URL || "https://localhost:8889"; try { const start = Date.now(); const resp = await fetch(`${url}/health`, { signal: AbortSignal.timeout(5000) }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/feed", async (req, res) => { const url = process.env.FEED_URL || "http://localhost:8787"; try { const start = Date.now(); const resp = await fetch(`${url}/api/v1/health`, { signal: AbortSignal.timeout(5000) }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/feed/info", async (req, res) => { const url = process.env.FEED_URL || "http://localhost:8787"; try { const start = Date.now(); const resp = await fetch(`${url}/api/v1`, { signal: AbortSignal.timeout(5000) }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/feed/playlists", async (req, res) => { const url = process.env.FEED_URL || "http://localhost:8787"; const apiSecret = process.env.FEED_API_SECRET || ""; try { const start = Date.now(); const headers = apiSecret ? { Authorization: `Bearer ${apiSecret}` } : {}; const resp = await fetch(`${url}/api/v1/playlists?limit=100`, { headers, signal: AbortSignal.timeout(10000), }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/feed/channels", async (req, res) => { const url = process.env.FEED_URL || "http://localhost:8787"; const apiSecret = process.env.FEED_API_SECRET || ""; try { const start = Date.now(); const headers = apiSecret ? { Authorization: `Bearer ${apiSecret}` } : {}; const resp = await fetch(`${url}/api/v1/channels?limit=100`, { headers, signal: AbortSignal.timeout(10000), }); const data = await resp.json(); res.json({ status: "ok", responseMs: Date.now() - start, ...data }); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); // --- Lith stats proxy --- const LITH_URL = process.env.LITH_URL || "https://aesthetic.computer"; app.get("/api/services/lith/stats", async (req, res) => { try { const resp = await fetch(`${LITH_URL}/lith/stats`, { signal: AbortSignal.timeout(5000) }); res.json(await resp.json()); } catch (err) { res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/services/lith/errors", async (req, res) => { try { const resp = await fetch(`${LITH_URL}/lith/errors?limit=${req.query.limit || 100}`, { signal: AbortSignal.timeout(5000) }); res.json(await resp.json()); } catch (err) { res.json({ errors: [], error: err.message }); } }); app.get("/api/services/lith/requests", async (req, res) => { try { const resp = await fetch(`${LITH_URL}/lith/requests?limit=${req.query.limit || 100}`, { signal: AbortSignal.timeout(5000) }); res.json(await resp.json()); } catch (err) { res.json({ requests: [], error: err.message }); } }); app.get("/api/services/billing", async (req, res) => { const billingUrl = process.env.BILLING_URL || "https://aesthetic.computer/api/billing"; try { const start = Date.now(); const authHeader = req.headers.authorization || ""; const resp = await fetch(billingUrl, { headers: authHeader ? { Authorization: authHeader } : {}, signal: AbortSignal.timeout(10000), }); let data = null; try { data = await resp.json(); } catch { data = null; } if (!resp.ok) { return res.status(resp.status).json({ status: "error", responseMs: Date.now() - start, error: data?.error || `Billing API error (${resp.status})`, }); } return res.json({ status: "ok", responseMs: Date.now() - start, ...data, }); } catch (err) { return res.json({ status: "unreachable", error: err.message }); } }); app.get("/api/firehose/history", async (req, res) => { if (!db) return res.json([]); const limit = Math.min(parseInt(req.query.limit) || 100, 1000); const ns = req.query.ns || null; const query = ns ? { ns } : {}; try { const events = await db.collection(FIREHOSE_COLLECTION) .find(query).sort({ time: -1 }).limit(limit).toArray(); res.json(events.reverse()); } catch (err) { res.status(500).json({ error: err.message }); } }); app.get("/api/firehose/stats", async (req, res) => { if (!db) return res.json({}); try { const col = db.collection(FIREHOSE_COLLECTION); const total = await col.estimatedDocumentCount(); const pipeline = [ { $group: { _id: { ns: "$ns", op: "$op" }, count: { $sum: 1 } } }, { $sort: { count: -1 } }, ]; const breakdown = await col.aggregate(pipeline).toArray(); res.json({ total, breakdown }); } catch (err) { res.status(500).json({ error: err.message }); } }); // --- Database Browser --- app.get("/api/db/browse/:collection", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); const colName = req.params.collection; const skip = Math.max(0, parseInt(req.query.skip) || 0); const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 25)); const sortField = req.query.sort || "_id"; const sortDir = req.query.dir === "asc" ? 1 : -1; const q = req.query.q || ""; try { const col = db.collection(colName); let filter = {}; if (q) { // Search by _id (string or ObjectId) or text match on common fields const conditions = [ { _id: q }, ]; if (ObjectId.isValid(q) && q.length === 24) { conditions.push({ _id: new ObjectId(q) }); } // Regex search on string fields const regex = { $regex: q, $options: "i" }; conditions.push( { handle: regex }, { user: regex }, { name: regex }, { slug: regex }, { text: regex }, { email: regex }, { code: regex }, { mood: regex }, { piece: regex }, ); filter = { $or: conditions }; } const [docs, total] = await Promise.all([ col.find(filter).sort({ [sortField]: sortDir }).skip(skip).limit(limit).toArray(), col.countDocuments(filter), ]); res.json({ docs, total, skip, limit }); } catch (err) { res.status(500).json({ error: err.message }); } }); app.get("/api/db/browse/:collection/:id", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); try { const col = db.collection(req.params.collection); const id = req.params.id; let doc = await col.findOne({ _id: id }); if (!doc && ObjectId.isValid(id) && id.length === 24) { doc = await col.findOne({ _id: new ObjectId(id) }); } if (!doc) return res.status(404).json({ error: "Document not found" }); res.json(doc); } catch (err) { res.status(500).json({ error: err.message }); } }); app.put("/api/db/browse/:collection/:id", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); const { _id, ...update } = req.body; try { const col = db.collection(req.params.collection); const id = req.params.id; let result = await col.updateOne({ _id: id }, { $set: update }); if (result.matchedCount === 0 && ObjectId.isValid(id) && id.length === 24) { result = await col.updateOne({ _id: new ObjectId(id) }, { $set: update }); } if (result.matchedCount === 0) return res.status(404).json({ error: "Document not found" }); log("info", `browse: updated ${req.params.collection}/${id}`); res.json({ ok: true, modified: result.modifiedCount }); } catch (err) { res.status(500).json({ error: err.message }); } }); app.delete("/api/db/browse/:collection/:id", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); try { const col = db.collection(req.params.collection); const id = req.params.id; let result = await col.deleteOne({ _id: id }); if (result.deletedCount === 0 && ObjectId.isValid(id) && id.length === 24) { result = await col.deleteOne({ _id: new ObjectId(id) }); } if (result.deletedCount === 0) return res.status(404).json({ error: "Document not found" }); log("info", `browse: deleted ${req.params.collection}/${id}`); res.json({ ok: true }); } catch (err) { res.status(500).json({ error: err.message }); } }); // --- Instagram Admin Routes --- app.get("/api/insta/status", async (req, res) => { const sessionDoc = db ? await db.collection("insta-sessions").findOne({ _id: igSessionUsername }).catch(() => null) : null; res.json({ loggedIn: igLoggedIn, username: igSessionUsername || null, lastUsed: igLastUsed ? new Date(igLastUsed).toISOString() : null, sessionAge: sessionDoc?.updatedAt ? Math.round((Date.now() - new Date(sessionDoc.updatedAt).getTime()) / 1000) : null, challengeInProgress: igChallengeInProgress, }); }); app.post("/api/insta/login", async (req, res) => { if (!db) return res.status(500).json({ error: "Database not connected" }); const secrets = await db.collection("secrets").findOne({ _id: "instagram" }); if (!secrets?.username || !secrets?.password) { return res.status(400).json({ error: "Instagram credentials not in MongoDB secrets" }); } const username = secrets.username; const password = secrets.password; log("info", `insta login attempt for @${username}`); igClient = new IgApiClient(); igClient.state.generateDevice(username); igSessionUsername = username; igClient.request.end$.subscribe(async () => { await saveInstaSession(igClient, username); }); // Pre-login flow (instagram-cli pattern) try { await igClient.launcher.preLoginSync(); log("info", "insta preLoginSync OK"); } catch (e) { log("warn", `insta preLoginSync failed: ${e.message}`); } try { await igClient.account.login(username, password); igLoggedIn = true; igLastUsed = Date.now(); // Post-login flow try { await igClient.feed.reelsTray("cold_start").request(); await igClient.feed.timeline("cold_start_fetch").request(); } catch (e) { log("warn", `insta postLoginFlow failed: ${e.message}`); } await saveInstaSession(igClient, username); log("info", `insta login success for @${username}`); res.json({ ok: true, username }); } catch (err) { if (err instanceof IgCheckpointError) { log("info", "insta checkpoint triggered, requesting verification code"); try { await igClient.challenge.auto(true); igChallengeInProgress = true; return res.json({ ok: false, challenge: true, message: "Verification code sent (check email/SMS). Submit via /api/insta/challenge.", }); } catch (challengeErr) { return res.status(500).json({ error: `Challenge setup failed: ${challengeErr.message}` }); } } if (err instanceof IgLoginTwoFactorRequiredError) { const twoFactorInfo = err.response.body.two_factor_info; igChallengeInProgress = true; return res.json({ ok: false, twoFactor: true, method: twoFactorInfo.totp_two_factor_on ? "authenticator" : "sms", twoFactorIdentifier: twoFactorInfo.two_factor_identifier, message: "Enter 2FA code via /api/insta/challenge.", }); } if (err instanceof IgLoginBadPasswordError) { return res.status(401).json({ error: "Bad password. Check credentials in MongoDB secrets." }); } log("error", `insta login failed: ${err.message}`); return res.status(500).json({ error: err.message }); } }); app.post("/api/insta/challenge", async (req, res) => { if (!igClient || !igChallengeInProgress) { return res.status(400).json({ error: "No challenge in progress" }); } const { code, twoFactorIdentifier, method } = req.body || {}; if (!code) return res.status(400).json({ error: "code is required" }); try { if (twoFactorIdentifier) { // 2FA flow await igClient.account.twoFactorLogin({ username: igSessionUsername, verificationCode: String(code).trim(), twoFactorIdentifier, verificationMethod: method === "authenticator" ? "0" : "1", }); } else { // Checkpoint flow await igClient.challenge.sendSecurityCode(String(code).trim()); } igLoggedIn = true; igChallengeInProgress = false; igLastUsed = Date.now(); // Post-login flow try { await igClient.feed.reelsTray("cold_start").request(); await igClient.feed.timeline("cold_start_fetch").request(); } catch (e) { log("warn", `insta postLoginFlow failed: ${e.message}`); } await saveInstaSession(igClient, igSessionUsername); log("info", `insta challenge completed for @${igSessionUsername}`); res.json({ ok: true, username: igSessionUsername }); } catch (err) { log("error", `insta challenge failed: ${err.message}`); res.status(400).json({ error: `Challenge verification failed: ${err.message}` }); } }); app.post("/api/insta/logout", async (req, res) => { igClient = null; igLoggedIn = false; igChallengeInProgress = false; igLastUsed = null; if (db && igSessionUsername) { await db.collection("insta-sessions").deleteOne({ _id: igSessionUsername }).catch(() => {}); } log("info", `insta session cleared for @${igSessionUsername}`); igSessionUsername = null; res.json({ ok: true }); }); // --- TikTok Admin Routes --- app.get("/api/tiktok/status", async (req, res) => { const token = await loadTiktokSession(); const sessionDoc = db ? await db.collection("tiktok-sessions").findOne({ _id: "default" }).catch(() => null) : null; res.json({ connected: !!token?.access_token, username: token?.username || null, openId: token?.open_id || null, scope: token?.scope || null, lastUsed: tiktokLastUsed ? new Date(tiktokLastUsed).toISOString() : null, expiresAt: token?.expires_at ? new Date(token.expires_at).toISOString() : null, sessionAge: sessionDoc?.updatedAt ? Math.round((Date.now() - new Date(sessionDoc.updatedAt).getTime()) / 1000) : null, }); }); app.get("/api/tiktok/auth", (req, res) => { if (!TIKTOK_CLIENT_KEY) return res.status(500).json({ error: "TIKTOK_CLIENT_KEY not configured" }); const scopes = "user.info.basic,user.info.profile,user.info.stats,video.list"; const url = `https://www.tiktok.com/v2/auth/authorize/?client_key=${TIKTOK_CLIENT_KEY}&scope=${scopes}&response_type=code&redirect_uri=${encodeURIComponent(TIKTOK_REDIRECT_URI)}`; res.json({ url }); }); app.post("/api/tiktok/disconnect", async (req, res) => { tiktokToken = null; tiktokLastUsed = null; if (db) { await db.collection("tiktok-sessions").deleteOne({ _id: "default" }).catch(() => {}); } log("info", "tiktok session disconnected"); res.json({ ok: true }); }); app.post("/api/tiktok/refresh", async (req, res) => { const ok = await refreshTiktokToken(); res.json({ ok, token: ok ? { expiresAt: new Date(tiktokToken.expires_at).toISOString() } : null }); }); // --- Desktop Release Distribution --- const DESKTOP_BUCKET = "releases-aesthetic-computer"; const DESKTOP_PREFIX = "desktop/"; const DESKTOP_BASE_URL = "https://releases.aesthetic.computer/desktop"; async function ensureReleasesCollection() { if (!db) return; try { const col = db.collection("releases"); await col.createIndex({ version: 1 }, { unique: true }); await col.createIndex({ current: 1 }); log("info", "releases collection ready"); } catch (err) { log("error", `releases index setup: ${err.message}`); } } // Public routes (CORS-enabled, no auth) app.use("/desktop", (req, res, next) => { res.header("Access-Control-Allow-Origin", "*"); res.header("Access-Control-Allow-Methods", "GET, OPTIONS"); res.header("Access-Control-Allow-Headers", "Content-Type"); if (req.method === "OPTIONS") return res.sendStatus(200); next(); }); app.get("/desktop/latest", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); try { const release = await db.collection("releases").findOne({ current: true }); if (!release) return res.status(404).json({ error: "No release published" }); res.json({ version: release.version, publishedAt: release.publishedAt, releaseNotes: release.releaseNotes || null, platforms: release.platforms, }); } catch (err) { res.status(500).json({ error: err.message }); } }); app.get("/desktop/download/:platform", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); const platform = req.params.platform; try { const release = await db.collection("releases").findOne({ current: true }); if (!release) return res.status(404).json({ error: "No release published" }); const plat = release.platforms?.[platform]; if (!plat?.url) return res.status(404).json({ error: `No ${platform} build available` }); res.redirect(302, plat.url); } catch (err) { res.status(500).json({ error: err.message }); } }); // Admin routes app.post("/api/desktop/register", async (req, res) => { if (!db) return res.status(503).json({ error: "Database not connected" }); const { version, platforms, releaseNotes } = req.body; if (!version || !platforms) { return res.status(400).json({ error: "version and platforms required" }); } // Build full URLs from filenames for (const [key, plat] of Object.entries(platforms)) { if (plat.filename && !plat.url) { plat.url = `${DESKTOP_BASE_URL}/${plat.filename}`; } } try { // Unset current on all previous releases await db.collection("releases").updateMany({}, { $set: { current: false } }); // Upsert this release await db.collection("releases").updateOne( { version }, { $set: { version, platforms, releaseNotes: releaseNotes || null, publishedAt: new Date(), publishedBy: req.auth?.handle || "unknown", current: true, }, }, { upsert: true }, ); log("info", `desktop release registered: v${version} by @${req.auth?.handle}`); res.json({ ok: true, version }); } catch (err) { log("error", `desktop register failed: ${err.message}`); res.status(500).json({ error: err.message }); } }); app.get("/api/desktop/releases", async (req, res) => { if (!db) return res.json({ releases: [] }); try { const releases = await db.collection("releases") .find({}).sort({ publishedAt: -1 }).limit(20).toArray(); res.json({ releases }); } catch (err) { res.status(500).json({ error: err.message }); } }); // --- Dashboard (loaded from file, reloadable via SIGHUP) --- const DASHBOARD_PATH = path.join(__dirname, "dashboard.html"); let dashboardHtml = ""; function loadDashboard() { try { dashboardHtml = fs.readFileSync(DASHBOARD_PATH, "utf-8"); log("info", `dashboard loaded (${(dashboardHtml.length / 1024).toFixed(0)} KB)`); } catch (err) { log("error", `dashboard load failed: ${err.message}`); } } loadDashboard(); app.get("/", (req, res) => { res.setHeader("Content-Type", "text/html"); res.send(dashboardHtml); }); // --- 404 --- app.use((req, res) => res.status(404).json({ error: "Not found" })); // --- Server Start --- let server; if (dev) { try { const httpsOpts = { key: fs.readFileSync("../ssl-dev/localhost-key.pem"), cert: fs.readFileSync("../ssl-dev/localhost.pem"), }; server = https.createServer(httpsOpts, app); } catch { log("warn", "no SSL certs, falling back to HTTP"); server = http.createServer(app); } } else { server = http.createServer(app); } // --- WebSocket --- wss = new WebSocketServer({ server, path: "/ws" }); wss.on("connection", async (ws) => { log("info", "dashboard client connected"); for (const entry of activityLog.slice(0, 30).reverse()) { ws.send(JSON.stringify({ logEntry: entry })); } ws.on("close", () => log("info", "dashboard client disconnected")); }); // --- Boot --- await connectMongo(); await loadHandleCache(); await ensureFirehoseCollection(); await ensureReleasesCollection(); startFirehose(); await connectAtlas(); await connectRedis(); await connectRedisSub(); // Restore TikTok session on startup loadTiktokSession().catch(() => {}); server.listen(PORT, () => { const proto = dev ? "https" : "http"; log("info", `silo running on ${proto}://localhost:${PORT}`); }); // --- Shutdown --- function shutdown(signal) { log("info", `received ${signal}, shutting down...`); if (changeStream) changeStream.close().catch(() => {}); wss.clients.forEach((ws) => ws.close()); server.close(); mongoClient?.close(); if (atlasClient && atlasClient !== mongoClient) atlasClient?.close(); redisClient?.quit().catch(() => {}); redisSub?.quit().catch(() => {}); setTimeout(() => process.exit(0), 500); } process.on("SIGTERM", () => shutdown("SIGTERM")); process.on("SIGINT", () => shutdown("SIGINT")); // --- SIGHUP: hot-reload dashboard.html without dropping connections --- process.on("SIGHUP", () => { log("info", "SIGHUP received, reloading dashboard..."); loadDashboard(); });