@cryptiklemur/lattice 0.0.0

package/client/src/styles/global.css

@@ -0,0 +1,167 @@
+@import "tailwindcss";
+@plugin "daisyui";
+@plugin "@tailwindcss/typography";
+@plugin "daisyui/theme" {
+  name: "lattice-dark";
+  default: true;
+  prefersdark: true;
+  color-scheme: dark;
+  --color-base-100: oklch(13% 0.02 280);
+  --color-base-200: oklch(16% 0.02 280);
+  --color-base-300: oklch(20% 0.02 280);
+  --color-base-content: oklch(90% 0.02 280);
+  --color-primary: oklch(55% 0.25 280);
+  --color-primary-content: oklch(98% 0.01 280);
+  --color-secondary: oklch(60% 0.2 280);
+  --color-secondary-content: oklch(98% 0.01 280);
+  --color-accent: oklch(65% 0.25 150);
+  --color-accent-content: oklch(98% 0.01 150);
+  --color-neutral: oklch(25% 0.02 280);
+  --color-neutral-content: oklch(85% 0.02 280);
+  --color-info: oklch(65% 0.2 240);
+  --color-info-content: oklch(98% 0.01 240);
+  --color-success: oklch(70% 0.2 150);
+  --color-success-content: oklch(98% 0.01 150);
+  --color-warning: oklch(80% 0.2 85);
+  --color-warning-content: oklch(20% 0.05 85);
+  --color-error: oklch(65% 0.25 25);
+  --color-error-content: oklch(98% 0.01 25);
+  --radius-selector: 0.5rem;
+  --radius-field: 0.25rem;
+  --radius-box: 0.5rem;
+  --size-selector: 0.25rem;
+  --size-field: 0.25rem;
+  --border: 1px;
+  --depth: 1;
+  --noise: 0;
+}
+
+:root {
+  --sidebar-width: 260px;
+  --node-rail-width: 52px;
+
+  --font-ui: "IBM Plex Sans", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --font-mono: "JetBrains Mono", "Berkeley Mono", "Geist Mono", ui-monospace, monospace;
+  --font-heading: "JetBrains Mono", "Berkeley Mono", ui-monospace, monospace;
+}
+
+html, body {
+  height: 100%;
+  width: 100%;
+  max-width: 100vw;
+  overflow-x: hidden;
+  font-family: var(--font-ui);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+#root {
+  height: 100%;
+  width: 100%;
+  max-width: 100vw;
+  display: flex;
+  overflow: hidden;
+  position: relative;
+}
+
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: oklch(from var(--color-base-content) l c h / 0.15);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: oklch(from var(--color-base-content) l c h / 0.25);
+}
+
+* {
+  scrollbar-width: thin;
+  scrollbar-color: oklch(from var(--color-base-content) l c h / 0.15) transparent;
+}
+
+.prose pre {
+  border-radius: 0.5rem;
+  border: 1px solid oklch(from var(--color-base-content) l c h / 0.1);
+  font-family: var(--font-mono);
+  font-size: 13px;
+  line-height: 1.6;
+}
+
+.prose code {
+  font-family: var(--font-mono);
+  font-size: 13px;
+  padding: 0.15em 0.3em;
+  border-radius: 0.25rem;
+  background: oklch(from var(--color-base-content) l c h / 0.08);
+}
+
+.prose pre code {
+  padding: 0;
+  background: transparent;
+}
+
+.bg-lattice-grid {
+  background-color: transparent;
+}
+
+@media (min-width: 640px) {
+  .bg-lattice-grid {
+    background-image: radial-gradient(circle, oklch(90% 0.02 280 / 0.05) 1px, transparent 1px);
+    background-size: 24px 24px;
+  }
+}
+
+@keyframes pulse {
+  0%, 80%, 100% { opacity: 0.2; transform: scale(0.8); }
+  40% { opacity: 1; transform: scale(1); }
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+@keyframes toast-in {
+  from { opacity: 0; transform: translateX(12px); }
+  to { opacity: 1; transform: translateX(0); }
+}
+
+@media (pointer: coarse) {
+  .btn-xs,
+  .btn-sm,
+  .select-xs,
+  .select-sm {
+    min-height: 44px;
+    min-width: 44px;
+  }
+
+  .select-xs,
+  .select-sm {
+    min-width: unset;
+  }
+}
+
+.scrollbar-hidden {
+  scrollbar-width: none;
+  -ms-overflow-style: none;
+}
+
+.scrollbar-hidden::-webkit-scrollbar {
+  display: none;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+  }
+}

package/client/src/styles/theme-vars.css

@@ -0,0 +1,18 @@
+:root {
+  --bg-primary: var(--base00);
+  --bg-secondary: var(--base01);
+  --bg-tertiary: var(--base02);
+  --text-muted: var(--base03);
+  --text-secondary: var(--base04);
+  --text-primary: var(--base05);
+  --text-bright: var(--base06);
+  --text-accent: var(--base07);
+  --red: var(--base08);
+  --orange: var(--base09);
+  --yellow: var(--base0A);
+  --green: var(--base0B);
+  --cyan: var(--base0C);
+  --blue: var(--base0D);
+  --purple: var(--base0E);
+  --magenta: var(--base0F);
+}

package/client/src/themes/index.ts

@@ -0,0 +1,79 @@
+import amoled from "../../../themes/amoled.json";
+import ayuLight from "../../../themes/ayu-light.json";
+import catppuccinLatte from "../../../themes/catppuccin-latte.json";
+import catppuccinMocha from "../../../themes/catppuccin-mocha.json";
+import clayLight from "../../../themes/clay-light.json";
+import clay from "../../../themes/clay.json";
+import dracula from "../../../themes/dracula.json";
+import everforestLight from "../../../themes/everforest-light.json";
+import everforest from "../../../themes/everforest.json";
+import githubLight from "../../../themes/github-light.json";
+import gruvboxDark from "../../../themes/gruvbox-dark.json";
+import gruvboxLight from "../../../themes/gruvbox-light.json";
+import monokai from "../../../themes/monokai.json";
+import nordLight from "../../../themes/nord-light.json";
+import nord from "../../../themes/nord.json";
+import oneDark from "../../../themes/one-dark.json";
+import oneLight from "../../../themes/one-light.json";
+import rosePineDawn from "../../../themes/rose-pine-dawn.json";
+import rosePine from "../../../themes/rose-pine.json";
+import solarizedDark from "../../../themes/solarized-dark.json";
+import solarizedLight from "../../../themes/solarized-light.json";
+import tokyoNightLight from "../../../themes/tokyo-night-light.json";
+import tokyoNight from "../../../themes/tokyo-night.json";
+
+export interface ThemeColors {
+  base00: string;
+  base01: string;
+  base02: string;
+  base03: string;
+  base04: string;
+  base05: string;
+  base06: string;
+  base07: string;
+  base08: string;
+  base09: string;
+  base0A: string;
+  base0B: string;
+  base0C: string;
+  base0D: string;
+  base0E: string;
+  base0F: string;
+}
+
+export interface Theme extends ThemeColors {
+  name: string;
+  author: string;
+  variant: "dark" | "light";
+}
+
+export interface ThemeEntry {
+  id: string;
+  theme: Theme;
+}
+
+export var themes: ThemeEntry[] = [
+  { id: "amoled", theme: amoled as Theme },
+  { id: "ayu-light", theme: ayuLight as Theme },
+  { id: "catppuccin-latte", theme: catppuccinLatte as Theme },
+  { id: "catppuccin-mocha", theme: catppuccinMocha as Theme },
+  { id: "clay-light", theme: clayLight as Theme },
+  { id: "clay", theme: clay as Theme },
+  { id: "dracula", theme: dracula as Theme },
+  { id: "everforest-light", theme: everforestLight as Theme },
+  { id: "everforest", theme: everforest as Theme },
+  { id: "github-light", theme: githubLight as Theme },
+  { id: "gruvbox-dark", theme: gruvboxDark as Theme },
+  { id: "gruvbox-light", theme: gruvboxLight as Theme },
+  { id: "monokai", theme: monokai as Theme },
+  { id: "nord-light", theme: nordLight as Theme },
+  { id: "nord", theme: nord as Theme },
+  { id: "one-dark", theme: oneDark as Theme },
+  { id: "one-light", theme: oneLight as Theme },
+  { id: "rose-pine-dawn", theme: rosePineDawn as Theme },
+  { id: "rose-pine", theme: rosePine as Theme },
+  { id: "solarized-dark", theme: solarizedDark as Theme },
+  { id: "solarized-light", theme: solarizedLight as Theme },
+  { id: "tokyo-night-light", theme: tokyoNightLight as Theme },
+  { id: "tokyo-night", theme: tokyoNight as Theme },
+];

package/client/src/utils/findDuplicateKeys.ts

@@ -0,0 +1,12 @@
+export function findDuplicateKeys(entries: Array<{ key: string }>): Set<string> {
+  var seen = new Map<string, number>();
+  var dupes = new Set<string>();
+  for (var i = 0; i < entries.length; i++) {
+    var k = entries[i].key.trim();
+    if (!k) continue;
+    var count = (seen.get(k) || 0) + 1;
+    seen.set(k, count);
+    if (count > 1) dupes.add(k);
+  }
+  return dupes;
+}

package/client/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "jsx": "react-jsx"
+  },
+  "include": [
+    "src"
+  ],
+  "references": [
+    { "path": "../shared" }
+  ]
+}

package/client/vite.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+export default defineConfig({
+  plugins: [tailwindcss(), react()],
+  server: {
+    host: "0.0.0.0",
+    open: true,
+    proxy: {
+      "/ws": {
+        target: "ws://localhost:7654",
+        ws: true,
+      },
+      "/api": {
+        target: "http://localhost:7654",
+      },
+    },
+  },
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@cryptiklemur/lattice",
+  "version": "0.0.0",
+  "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
+  "license": "MIT",
+  "author": "Aaron Scherer <me@aaronscherer.me>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cryptiklemur/lattice.git"
+  },
+  "homepage": "https://github.com/cryptiklemur/lattice",
+  "bugs": {
+    "url": "https://github.com/cryptiklemur/lattice/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "dashboard",
+    "mcp",
+    "agentic",
+    "ai",
+    "mesh",
+    "lattice"
+  ],
+  "bin": {
+    "lattice": "./server/src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run --filter '*' dev",
+    "build": "bun run --filter '*' build",
+    "lint": "bun run --filter '*' lint",
+    "typecheck": "bunx tsc --noEmit -p tsconfig.json"
+  },
+  "workspaces": [
+    "shared",
+    "server",
+    "client"
+  ],
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "semantic-release": "^25.0.3"
+  }
+}

package/server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@lattice/server",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "bun --watch src/index.ts daemon",
+    "start": "bun src/index.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.79",
+    "@lattice/shared": "workspace:*",
+    "bonjour-service": "^1.3.0",
+    "js-tiktoken": "^1.0.21",
+    "node-pty": "^1.1.0",
+    "qrcode": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/qrcode": "^1.5.6",
+    "bun-types": "latest"
+  }
+}

package/server/src/auth/passphrase.ts

@@ -0,0 +1,48 @@
+import { scryptSync, randomBytes, timingSafeEqual } from "node:crypto";
+
+var activeSessions = new Set<string>();
+
+export function hashPassphrase(passphrase: string): string {
+  var salt = randomBytes(16).toString("hex");
+  var hash = scryptSync(passphrase, salt, 64).toString("hex");
+  return salt + ":" + hash;
+}
+
+export function verifyPassphrase(passphrase: string, storedHash: string): boolean {
+  var parts = storedHash.split(":");
+  if (parts.length !== 2) {
+    return false;
+  }
+  var salt = parts[0];
+  var hash = parts[1];
+  try {
+    var derived = scryptSync(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(): string {
+  return randomBytes(32).toString("hex");
+}
+
+export function addSession(token: string): void {
+  activeSessions.add(token);
+}
+
+export function removeSession(token: string): void {
+  activeSessions.delete(token);
+}
+
+export function isValidSession(token: string): boolean {
+  return activeSessions.has(token);
+}
+
+export function clearSessions(): void {
+  activeSessions.clear();
+}

package/server/src/config.ts

@@ -0,0 +1,55 @@
+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 "@lattice/shared";
+import type { LatticeConfig } from "@lattice/shared";
+
+var home = join(homedir(), LATTICE_HOME_DIR);
+var cachedConfig: LatticeConfig | null = null;
+
+export function getLatticeHome(): string {
+  if (!existsSync(home)) {
+    mkdirSync(home, { recursive: true });
+  }
+  return home;
+}
+
+export function getConfigPath(): string {
+  return join(getLatticeHome(), "config.json");
+}
+
+export function loadConfig(): LatticeConfig {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+  var configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return createDefaultConfig();
+  }
+  var raw = readFileSync(configPath, "utf-8");
+  cachedConfig = JSON.parse(raw) as LatticeConfig;
+  return cachedConfig;
+}
+
+export function saveConfig(config: LatticeConfig): void {
+  var configPath = getConfigPath();
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  cachedConfig = config;
+}
+
+export function invalidateConfigCache(): void {
+  cachedConfig = null;
+}
+
+function createDefaultConfig(): LatticeConfig {
+  var config: LatticeConfig = {
+    port: DEFAULT_PORT,
+    name: hostname(),
+    tls: false,
+    debug: false,
+    globalEnv: {},
+    projects: [],
+  };
+  saveConfig(config);
+  return config;
+}