ciphermesh 1.0.0

package/src/shared/constants.js

@@ -0,0 +1,126 @@
+export const PROTOCOL_VERSION = 1;
+
+// Network
+export const SERVER_PORT = 3600;
+export const HEARTBEAT_INTERVAL_MS = 30_000;
+export const RECONNECT_BASE_MS = 1_000;
+export const RECONNECT_MAX_MS = 30_000;
+
+// Limits
+export const MAX_NICKNAME_LENGTH = 20;
+export const MAX_PAYLOAD_SIZE = 65_536;
+export const RATE_LIMIT_PER_SECOND = 30;
+export const SESSION_TIMEOUT_MS = 300_000;
+
+// Server hardening
+export const MAX_CONNECTIONS_TOTAL = 500; // global socket cap
+export const MAX_CONNECTIONS_PER_IP = 20; // per-source-IP socket cap
+export const JOIN_TIMEOUT_MS = 15_000; // drop sockets that never JOIN
+export const MESSAGE_RATE_LIMIT_PER_SECOND = 60; // per connection, ALL message types
+
+// Crypto sizes (libsodium Curve25519 + XSalsa20-Poly1305)
+export const NONCE_SIZE = 24;
+export const PUBLIC_KEY_SIZE = 32;
+export const SECRET_KEY_SIZE = 32;
+export const MAC_SIZE = 16;
+export const SHARED_KEY_SIZE = 32;
+
+// Nonce structure offsets
+export const NONCE_TIMESTAMP_OFFSET = 0;
+export const NONCE_TIMESTAMP_SIZE = 8;
+export const NONCE_COUNTER_OFFSET = 8;
+export const NONCE_COUNTER_SIZE = 4;
+export const NONCE_RANDOM_OFFSET = 12;
+export const NONCE_RANDOM_SIZE = 12;
+
+// Anti-replay
+export const NONCE_MAX_AGE_MS = 30_000;
+
+// Offline queue
+export const OFFLINE_QUEUE_MAX_PER_PEER = 100;
+export const OFFLINE_QUEUE_MAX_AGE_MS = 3_600_000; // 1h
+export const OFFLINE_QUEUE_MAX_TOTAL = 1000;
+
+// Message padding (anti-metadata): every ciphertext is padded up to one of
+// these bucket sizes so the relay can't read the true plaintext length.
+export const MESSAGE_PAD_BUCKETS = [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+
+// Cover traffic (anti-metadata): when enabled, decoy messages are sent at
+// jittered intervals so an observer can't tell active chatting from idle.
+export const COVER_MIN_MS = 20_000; // shortest gap between decoys (jitter mode)
+export const COVER_MAX_MS = 60_000; // longest gap between decoys (jitter mode)
+export const COVER_MAX_FILLER = 2000; // random filler bytes → varied padding buckets
+// Constant-rate mode: fixed cadence. Each slot carries a queued real message or,
+// if none, a decoy — so the wire rate is steady whether you chat or idle.
+export const COVER_CONSTANT_MS = 3000;
+
+// Key rotation
+export const KEY_ROTATION_INTERVAL_MS = 3_600_000; // 1h
+export const KEY_ROTATION_GRACE_MS = 30_000; // 30s — keep old key for in-flight msgs
+
+// Double Ratchet (PFS)
+export const RATCHET_MAX_SKIP = 100;
+export const RATCHET_SKIP_KEY_MAX_AGE_MS = 60_000; // 60s
+
+// File transfer
+export const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+// 16KB raw. The chunk is base64'd into the JSON payload, encrypted, then the
+// ciphertext is base64'd again into the wire message — a ~1.78x expansion. At
+// 16KB the plaintext stays under padMessage's 2-byte length field (65535) and
+// the final wire frame (~29KB) stays well under MAX_PAYLOAD_SIZE.
+export const FILE_CHUNK_SIZE = 16_384;
+
+// Emoji map for reactions and inline shortcodes
+export const EMOJI_MAP = {
+  ':thumbsup:': '\uD83D\uDC4D',
+  ':heart:': '\u2764\uFE0F',
+  ':laugh:': '\uD83D\uDE02',
+  ':fire:': '\uD83D\uDD25',
+  ':check:': '\u2705',
+  ':x:': '\u274C',
+  ':eyes:': '\uD83D\uDC40',
+  ':clap:': '\uD83D\uDC4F',
+  ':smile:': '\uD83D\uDE04',
+  ':sad:': '\uD83D\uDE22',
+  ':cry:': '\uD83D\uDE2D',
+  ':party:': '\uD83C\uDF89',
+  ':rocket:': '\uD83D\uDE80',
+  ':100:': '\uD83D\uDCAF',
+  ':wave:': '\uD83D\uDC4B',
+  ':thinking:': '\uD83E\uDD14',
+  ':skull:': '\uD83D\uDC80',
+  ':pray:': '\uD83D\uDE4F',
+  ':ok:': '\uD83D\uDC4C',
+  ':poop:': '\uD83D\uDCA9',
+  ':thumbsdown:': '\uD83D\uDC4E',
+  ':wink:': '\uD83D\uDE09',
+  ':cool:': '\uD83D\uDE0E',
+  ':angry:': '\uD83D\uDE20',
+  ':love:': '\uD83D\uDE0D',
+  ':kiss:': '\uD83D\uDE18',
+  ':tongue:': '\uD83D\uDE1B',
+  ':shush:': '\uD83E\uDD2B',
+  ':star:': '\u2B50',
+  ':warning:': '\u26A0\uFE0F',
+  ':question:': '\u2753',
+  ':bulb:': '\uD83D\uDCA1',
+  ':lock:': '\uD83D\uDD12',
+  ':key:': '\uD83D\uDD11',
+  ':bell:': '\uD83D\uDD14',
+  ':tada:': '\uD83C\uDF8A',
+  ':coffee:': '\u2615',
+  ':beer:': '\uD83C\uDF7A',
+  ':pizza:': '\uD83C\uDF55',
+  ':ghost:': '\uD83D\uDC7B',
+  ':robot:': '\uD83E\uDD16',
+  ':alien:': '\uD83D\uDC7D',
+  ':sun:': '\u2600\uFE0F',
+  ':moon:': '\uD83C\uDF19',
+  ':zap:': '\u26A1',
+  ':boom:': '\uD83D\uDCA5',
+  ':muscle:': '\uD83D\uDCAA',
+  ':point_up:': '\u261D\uFE0F',
+  ':raised_hands:': '\uD83D\uDE4C',
+  ':facepalm:': '\uD83E\uDD26',
+  ':shrug:': '\uD83E\uDD37',
+};

package/src/shared/coverTraffic.js

@@ -0,0 +1,34 @@
+import { COVER_MIN_MS, COVER_MAX_MS, COVER_MAX_FILLER } from './constants.js';
+
+// Cover traffic hides *when* and *how much* you chat from a relay/observer that
+// can already only see ciphertext. Real messages are padded to fixed buckets
+// (MessageCrypto.padMessage), so a decoy with random filler is indistinguishable
+// from a real message on the wire. Decoys are dropped silently by the receiver.
+
+/**
+ * Jittered delay (ms) until the next decoy — uniform in [min, max].
+ * `rand` is injectable for deterministic tests.
+ */
+export function nextCoverDelay(rand = Math.random, min = COVER_MIN_MS, max = COVER_MAX_MS) {
+  return Math.round(min + rand() * (max - min));
+}
+
+/**
+ * Build a decoy payload. The random filler varies the plaintext length so the
+ * encrypted+padded decoy lands across the same buckets as real chat messages.
+ * @param {number} now - timestamp (Date.now())
+ * @param {() => number} rand - injectable RNG for tests
+ */
+export function coverPayload(now, rand = Math.random) {
+  const fillerLen = Math.floor(rand() * COVER_MAX_FILLER);
+  return JSON.stringify({
+    action: 'cover',
+    sentAt: now,
+    x: 'x'.repeat(fillerLen), // opaque filler; the receiver ignores it
+  });
+}
+
+/** True if a decoded payload is a decoy that should be dropped without any effect. */
+export function isCover(data) {
+  return !!data && data.action === 'cover';
+}

package/src/shared/dnd.js

@@ -0,0 +1,60 @@
+// Do-not-disturb / mentions-only notification gating.
+// mode: 'off' (normal), 'mentions' (only @mentions), 'on' (full silence).
+// An optional quiet-hours window makes the effective mode 'mentions' inside it.
+
+export function parseDndWindow(str) {
+  const m = String(str).match(/^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/);
+  if (!m) {
+    return null;
+  }
+  const h1 = Number(m[1]);
+  const min1 = Number(m[2]);
+  const h2 = Number(m[3]);
+  const min2 = Number(m[4]);
+  if (h1 > 23 || h2 > 23 || min1 > 59 || min2 > 59) {
+    return null;
+  }
+  return { start: h1 * 60 + min1, end: h2 * 60 + min2 };
+}
+
+export function inWindow(window, nowMinutes) {
+  if (!window) {
+    return false;
+  }
+  const { start, end } = window;
+  // Handle windows that wrap past midnight (e.g. 22:00-08:00).
+  return start <= end
+    ? nowMinutes >= start && nowMinutes < end
+    : nowMinutes >= start || nowMinutes < end;
+}
+
+// Whether an incoming message should notify at all. A 'true' result still lets
+// the caller apply its own sound/desktop-enabled toggles.
+export function shouldNotify(mode, window, nowMinutes, mentioned) {
+  const eff = inWindow(window, nowMinutes) ? 'mentions' : mode;
+  if (eff === 'on') {
+    return false; // full silence
+  }
+  if (eff === 'mentions') {
+    return !!mentioned;
+  }
+  return true; // 'off' → normal
+}
+
+export function nowMinutes(date = new Date()) {
+  return date.getHours() * 60 + date.getMinutes();
+}
+
+// True if `text` mentions `nickname` (via @nick or the bare word). Nicknames are
+// validated to [a-zA-Z0-9_-], so no regex escaping is needed.
+export function mentionsMe(text, nickname) {
+  if (typeof text !== 'string' || !nickname) {
+    return false;
+  }
+  const nick = nickname.toLowerCase();
+  const t = text.toLowerCase();
+  if (t.includes(`@${nick}`)) {
+    return true;
+  }
+  return new RegExp(`(^|[^a-z0-9_-])${nick}([^a-z0-9_-]|$)`).test(t);
+}

package/src/shared/emoji.js

@@ -0,0 +1,17 @@
+import { EMOJI_MAP } from './constants.js';
+
+const SHORTCODE_REGEX = /:([a-z0-9_+-]+):/g;
+
+/**
+ * Replace :shortcode: occurrences with their emoji. Unknown codes stay as-is.
+ */
+export function applyShortcodes(text) {
+  return text.replace(SHORTCODE_REGEX, (match) => EMOJI_MAP[match] || match);
+}
+
+/**
+ * Shortcodes starting with the given prefix (prefix includes the leading ':').
+ */
+export function shortcodeSuggestions(prefix) {
+  return Object.keys(EMOJI_MAP).filter((code) => code.startsWith(prefix));
+}

package/src/shared/fuzzy.js

@@ -0,0 +1,40 @@
+// Subsequence fuzzy matching for the command palette. `query` matches `text`
+// when its characters appear in order (not necessarily contiguous). Lower score
+// = better match (earlier positions, fewer gaps). Returns -1 for no match.
+
+export function fuzzyScore(text, query) {
+  if (!query) {
+    return 0;
+  }
+  const t = String(text).toLowerCase();
+  const q = query.toLowerCase();
+  let from = 0;
+  let score = 0;
+  let prev = -1;
+  for (const ch of q) {
+    const idx = t.indexOf(ch, from);
+    if (idx === -1) {
+      return -1;
+    }
+    score += idx; // earlier matches rank higher
+    if (prev !== -1 && idx !== prev + 1) {
+      score += 5; // penalise gaps (favour contiguous matches)
+    }
+    prev = idx;
+    from = idx + 1;
+  }
+  return score;
+}
+
+// Filter + rank items by fuzzy match against a query. `key` extracts the string
+// to match from each item. With no query, returns all items unchanged.
+export function fuzzyFilter(items, query, key = (x) => x) {
+  if (!query) {
+    return items.slice();
+  }
+  return items
+    .map((item) => ({ item, score: fuzzyScore(key(item), query) }))
+    .filter((x) => x.score >= 0)
+    .sort((a, b) => a.score - b.score || key(a.item).length - key(b.item).length)
+    .map((x) => x.item);
+}

package/src/shared/invite.js

@@ -0,0 +1,61 @@
+const INVITE_SCHEME = 'ciphermesh://';
+const ROOM_REGEX = /^[a-zA-Z0-9_-]{1,20}$/;
+const HOST_REGEX = /^[a-zA-Z0-9._-]+$/;
+
+/**
+ * Build an invite URI: ciphermesh://host:port/room
+ * @param {string} hostPort - "host:port" (ex: 100.124.6.27:3600)
+ * @param {string} [room] - room name (default: general)
+ * @returns {string|null} invite URI or null if input is invalid
+ */
+export function buildInvite(hostPort, room = 'general') {
+  const parsed = parseHostPort(hostPort);
+  if (!parsed || !ROOM_REGEX.test(room)) {
+    return null;
+  }
+  return `${INVITE_SCHEME}${parsed.host}:${parsed.port}/${room}`;
+}
+
+/**
+ * Parse an invite URI into its parts.
+ * @param {string} uri - ciphermesh://host:port[/room]
+ * @returns {{ host: string, port: number, room: string, wsUrl: string }|null}
+ */
+export function parseInvite(uri) {
+  if (typeof uri !== 'string' || !uri.startsWith(INVITE_SCHEME)) {
+    return null;
+  }
+
+  const rest = uri.slice(INVITE_SCHEME.length);
+  const slash = rest.indexOf('/');
+  const hostPort = slash === -1 ? rest : rest.slice(0, slash);
+  const room = slash === -1 ? 'general' : rest.slice(slash + 1) || 'general';
+
+  const parsed = parseHostPort(hostPort);
+  if (!parsed || !ROOM_REGEX.test(room)) {
+    return null;
+  }
+
+  return {
+    host: parsed.host,
+    port: parsed.port,
+    room,
+    wsUrl: `wss://${parsed.host}:${parsed.port}`,
+  };
+}
+
+function parseHostPort(hostPort) {
+  if (typeof hostPort !== 'string') {
+    return null;
+  }
+  const colon = hostPort.lastIndexOf(':');
+  if (colon === -1) {
+    return null;
+  }
+  const host = hostPort.slice(0, colon);
+  const port = parseInt(hostPort.slice(colon + 1), 10);
+  if (!HOST_REGEX.test(host) || !Number.isInteger(port) || port < 1 || port > 65535) {
+    return null;
+  }
+  return { host, port };
+}

package/src/shared/keyArt.js

@@ -0,0 +1,66 @@
+// Deterministic "randomart" for a key — the OpenSSH "drunken bishop" walk.
+// A bishop starts at the center of a 17x9 board and moves diagonally, one step
+// per 2-bit pair of the input bytes, incrementing a counter at each cell. The
+// resulting density map is drawn with coin characters. Same key → same picture,
+// so a changed key produces a visibly different picture (MITM detection aid).
+
+const WIDTH = 17;
+const HEIGHT = 9;
+const COINS = ' .o+=*BOX@%&#/^'; // index = visit count (clamped)
+
+/**
+ * @param {Buffer|Uint8Array} bytes - key material (e.g. the 32-byte public key)
+ * @param {string} [title] - short label centered on the top border
+ * @returns {string} multi-line box, 11 lines of 19 chars
+ */
+export function keyArt(bytes, title = '') {
+  const field = Array.from({ length: HEIGHT }, () => new Array(WIDTH).fill(0));
+
+  const startX = Math.floor(WIDTH / 2);
+  const startY = Math.floor(HEIGHT / 2);
+  let x = startX;
+  let y = startY;
+
+  for (const byte of bytes) {
+    let b = byte;
+    for (let i = 0; i < 4; i++) {
+      x += b & 0x1 ? 1 : -1; // bit 0 → right / left
+      y += b & 0x2 ? 1 : -1; // bit 1 → down / up
+      x = Math.max(0, Math.min(WIDTH - 1, x));
+      y = Math.max(0, Math.min(HEIGHT - 1, y));
+      field[y][x] += 1;
+      b >>= 2;
+    }
+  }
+
+  const lines = [border(title), ...rows(field, startX, startY, x, y), border('')];
+  return lines.join('\n');
+}
+
+function border(title) {
+  if (!title) {
+    return `+${'-'.repeat(WIDTH)}+`;
+  }
+  const label = `[${title.slice(0, WIDTH - 2)}]`;
+  const pad = WIDTH - label.length;
+  const left = Math.floor(pad / 2);
+  return `+${'-'.repeat(left)}${label}${'-'.repeat(pad - left)}+`;
+}
+
+function rows(field, startX, startY, endX, endY) {
+  const out = [];
+  for (let j = 0; j < HEIGHT; j++) {
+    let row = '|';
+    for (let i = 0; i < WIDTH; i++) {
+      if (i === startX && j === startY) {
+        row += 'S';
+      } else if (i === endX && j === endY) {
+        row += 'E';
+      } else {
+        row += COINS[Math.min(field[j][i], COINS.length - 1)];
+      }
+    }
+    out.push(`${row}|`);
+  }
+  return out;
+}

package/src/shared/logger.js

@@ -0,0 +1,38 @@
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3, silent: 4 };
+
+const currentLevel = LEVELS[process.env.LOG_LEVEL?.toLowerCase()] ?? LEVELS.info;
+
+function timestamp() {
+  return new Date().toLocaleTimeString('en-US', { hour12: false });
+}
+
+function format(level, module, message) {
+  return `[${timestamp()}] [${level.toUpperCase().padEnd(5)}] [${module}] ${message}`;
+}
+
+function createLogger(module) {
+  return {
+    debug: (msg) => {
+      if (currentLevel <= LEVELS.debug) {
+        console.log(format('debug', module, msg));
+      }
+    },
+    info: (msg) => {
+      if (currentLevel <= LEVELS.info) {
+        console.log(format('info', module, msg));
+      }
+    },
+    warn: (msg) => {
+      if (currentLevel <= LEVELS.warn) {
+        console.warn(format('warn', module, msg));
+      }
+    },
+    error: (msg) => {
+      if (currentLevel <= LEVELS.error) {
+        console.error(format('error', module, msg));
+      }
+    },
+  };
+}
+
+export { createLogger };

package/src/shared/panic.js

@@ -0,0 +1,38 @@
+import { StateManager } from '../crypto/StateManager.js';
+
+// Panic / duress wipe: securely delete every at-rest secret. Best-effort and
+// never throws — under duress it must run to completion no matter what.
+export function panicWipe({ historyStore, trustStore, auditLog } = {}) {
+  const wiped = [];
+  try {
+    new StateManager().clearState(); // encrypted session state
+    wiped.push('session');
+  } catch {
+    /* best effort */
+  }
+  try {
+    if (historyStore) {
+      historyStore.wipe();
+      wiped.push('history');
+    }
+  } catch {
+    /* best effort */
+  }
+  try {
+    if (trustStore) {
+      trustStore.wipe();
+      wiped.push('trust');
+    }
+  } catch {
+    /* best effort */
+  }
+  try {
+    if (auditLog) {
+      auditLog.wipe();
+      wiped.push('audit');
+    }
+  } catch {
+    /* best effort */
+  }
+  return wiped;
+}

package/src/shared/prompt.js

@@ -0,0 +1,31 @@
+/**
+ * Ask a question on a readline interface WITHOUT echoing the typed characters
+ * (for passphrases). Uses the standard readline `_writeToOutput` override so it
+ * composes with an existing readline/promises interface.
+ *
+ * @param {import('node:readline/promises').Interface} rl
+ * @param {string} query - prompt text (shown once)
+ * @returns {Promise<string>} the typed answer
+ */
+export function questionHidden(rl, query) {
+  const original = rl._writeToOutput?.bind(rl);
+  let promptShown = false;
+
+  rl._writeToOutput = (str) => {
+    if (!promptShown) {
+      // The first write is the prompt itself — show it, then mask the rest.
+      rl.output.write(query);
+      promptShown = true;
+      return;
+    }
+    // Preserve line breaks (so the cursor advances on Enter), swallow the
+    // character echoes so the passphrase never appears on screen.
+    if (str.includes('\n') || str.includes('\r')) {
+      rl.output.write('\n');
+    }
+  };
+
+  return rl.question(query).finally(() => {
+    rl._writeToOutput = original;
+  });
+}

package/src/shared/terminalGraphics.js

@@ -0,0 +1,72 @@
+// Detect and encode inline-image support for capable terminals (kitty / iTerm2).
+// The half-block preview always works; these enable full-resolution rendering
+// where the terminal supports a real graphics protocol.
+
+/**
+ * @returns {'kitty'|'iterm'|null}
+ */
+export function detectImageProtocol(env = process.env) {
+  if (env.TERM === 'xterm-kitty' || env.KITTY_WINDOW_ID) {
+    return 'kitty';
+  }
+  if (env.TERM_PROGRAM === 'iTerm.app' || env.LC_TERMINAL === 'iTerm2') {
+    return 'iterm';
+  }
+  return null;
+}
+
+export function supportsTrueColor(env = process.env) {
+  const ct = (env.COLORTERM || '').toLowerCase();
+  if (ct === 'truecolor' || ct === '24bit') {
+    return true;
+  }
+  return (env.TERM || '').includes('kitty') || env.TERM_PROGRAM === 'iTerm.app';
+}
+
+/**
+ * iTerm2 inline image escape. Accepts raw image bytes of any format.
+ * @param {Buffer} buffer
+ * @param {{ widthCells?: number }} [opts]
+ */
+export function encodeITermImage(buffer, opts = {}) {
+  const args = ['inline=1', `size=${buffer.length}`, 'preserveAspectRatio=1'];
+  if (opts.widthCells) {
+    args.push(`width=${opts.widthCells}`);
+  }
+  return `\x1b]1337;File=${args.join(';')}:${buffer.toString('base64')}\x07`;
+}
+
+/**
+ * kitty graphics protocol escape. Requires a PNG buffer (f=100), chunked so no
+ * single escape exceeds the protocol limit.
+ * @param {Buffer} pngBuffer
+ */
+export function encodeKittyImage(pngBuffer) {
+  const b64 = pngBuffer.toString('base64');
+  const CHUNK = 4096;
+  let out = '';
+  for (let i = 0; i < b64.length; i += CHUNK) {
+    const chunk = b64.slice(i, i + CHUNK);
+    const more = i + CHUNK < b64.length ? 1 : 0;
+    const control = i === 0 ? `f=100,a=T,m=${more}` : `m=${more}`;
+    out += `\x1b_G${control};${chunk}\x1b\\`;
+  }
+  return out;
+}
+
+/**
+ * Build the inline-image escape for the detected protocol.
+ * @param {'kitty'|'iterm'} protocol
+ * @param {{ raw: Buffer, png: Buffer }} images - raw bytes and a PNG re-encoding
+ * @param {{ widthCells?: number }} [opts]
+ * @returns {string|null}
+ */
+export function encodeInlineImage(protocol, images, opts = {}) {
+  if (protocol === 'iterm') {
+    return encodeITermImage(images.raw, opts);
+  }
+  if (protocol === 'kitty') {
+    return encodeKittyImage(images.png);
+  }
+  return null;
+}

package/src/shared/themes.js

@@ -0,0 +1,36 @@
+// Selectable colour themes for per-user nick colours. Each palette is a list of
+// blessed colour tokens (named colours or #hex). The banner keeps the neon
+// brand; themes affect the ongoing message colours, which is what you actually
+// look at all session.
+
+export const THEMES = {
+  neon: ['cyan', 'green', 'magenta', 'yellow', 'red'],
+  matrix: ['green', '#00ff41', '#39ff14', '#7fff00', '#00c853'],
+  mono: ['white', '#bbbbbb', '#888888', '#dddddd', '#00b8ff'],
+  sunset: ['red', 'yellow', 'magenta', '#ff7b00', '#ff2d95'],
+  ocean: ['cyan', 'blue', '#00b8ff', '#4cc9f0', '#7b2dff'],
+};
+
+const DEFAULT = 'neon';
+let active = DEFAULT;
+
+/** Set the active theme by name; ignores unknown names. Returns the active name. */
+export function setTheme(name) {
+  if (typeof name === 'string' && Object.prototype.hasOwnProperty.call(THEMES, name)) {
+    active = name;
+  }
+  return active;
+}
+
+export function getThemeName() {
+  return active;
+}
+
+/** The active palette (array of colour tokens). */
+export function nickPalette() {
+  return THEMES[active];
+}
+
+export function themeNames() {
+  return Object.keys(THEMES);
+}