auramaxx 0.0.1

package/src/lib/workspace-handlers.ts

@@ -0,0 +1,285 @@
+import { prisma } from './db';
+import {
+  WORKSPACE_EVENTS,
+  WorkspaceEvent,
+  WorkspaceData,
+  AppData,
+  AppUpdateData,
+  WorkspaceStateRequestData,
+  WorkspaceStateResponseData,
+  WorkspaceImportData,
+  createWorkspaceEvent,
+} from './events';
+
+/**
+ * Handle incoming workspace WebSocket messages
+ * Returns a response event if one should be sent back to the sender
+ */
+export async function handleWorkspaceMessage(
+  msg: WorkspaceEvent
+): Promise<WorkspaceEvent | null> {
+  console.log(`[WS] Handling workspace message: ${msg.type}`);
+
+  switch (msg.type) {
+    case WORKSPACE_EVENTS.STATE_REQUEST:
+      return handleStateRequest(msg.data as WorkspaceStateRequestData);
+
+    case WORKSPACE_EVENTS.WORKSPACE_CREATED:
+      await handleWorkspaceCreated(msg.data as WorkspaceData);
+      return null;
+
+    case WORKSPACE_EVENTS.WORKSPACE_DELETED:
+      await handleWorkspaceDeleted(msg.data as { workspaceId: string });
+      return null;
+
+    case WORKSPACE_EVENTS.WORKSPACE_UPDATED:
+      await handleWorkspaceUpdated(msg.data as WorkspaceData);
+      return null;
+
+    case WORKSPACE_EVENTS.APP_ADDED:
+      await handleAppAdded(msg.data as AppData);
+      return null;
+
+    case WORKSPACE_EVENTS.APP_REMOVED:
+      await handleAppRemoved(msg.data as { appId: string });
+      return null;
+
+    case WORKSPACE_EVENTS.APP_UPDATED:
+      await handleAppUpdated(msg.data as AppUpdateData);
+      return null;
+
+    case WORKSPACE_EVENTS.WORKSPACE_SAVE:
+      await handleWorkspaceSave(msg.data as { workspaceId: string });
+      return null;
+
+    case WORKSPACE_EVENTS.WORKSPACE_IMPORT:
+      await handleWorkspaceImport(msg.data as WorkspaceImportData);
+      return null;
+
+    default:
+      console.warn(`[WS] Unknown workspace event type: ${msg.type}`);
+      return null;
+  }
+}
+
+async function handleStateRequest(
+  data: WorkspaceStateRequestData
+): Promise<WorkspaceEvent<WorkspaceStateResponseData>> {
+  // Get all workspaces
+  const workspaces = await prisma.workspace.findMany({
+    orderBy: { order: 'asc' },
+  });
+
+  // Find the default or first workspace
+  let activeWorkspaceId: string = data.workspaceId ?? '';
+  if (!activeWorkspaceId) {
+    const defaultWorkspace = workspaces.find((w: any) => w.isDefault) || workspaces[0];
+    activeWorkspaceId = defaultWorkspace?.id || '';
+  }
+
+  // Get apps for the active workspace
+  const apps = activeWorkspaceId
+    ? await prisma.workspaceApp.findMany({
+        where: { workspaceId: activeWorkspaceId },
+      })
+    : [];
+
+  const response: WorkspaceStateResponseData = {
+    requestId: data.requestId,
+    workspaces: workspaces.map((w: any) => ({
+      id: w.id,
+      name: w.name,
+      slug: w.slug,
+      icon: w.icon || undefined,
+      emoji: w.emoji || undefined,
+      color: w.color || undefined,
+      order: w.order,
+      isDefault: w.isDefault,
+      isCloseable: w.isCloseable,
+    })),
+    activeWorkspaceId,
+    apps: apps.map((w: any) => ({
+      id: w.id,
+      workspaceId: w.workspaceId,
+      appType: w.appType,
+      x: w.x,
+      y: w.y,
+      width: w.width,
+      height: w.height,
+      zIndex: w.zIndex,
+      isVisible: w.isVisible,
+      isLocked: w.isLocked,
+      config: w.config ? JSON.parse(w.config) : undefined,
+    })),
+  };
+
+  return createWorkspaceEvent(WORKSPACE_EVENTS.STATE_RESPONSE, response, 'server');
+}
+
+async function handleWorkspaceCreated(data: WorkspaceData): Promise<void> {
+  // Generate a unique slug from the name
+  const baseSlug = data.slug || data.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  let slug = baseSlug;
+  let counter = 1;
+
+  // Ensure slug is unique
+  while (await prisma.workspace.findUnique({ where: { slug } })) {
+    slug = `${baseSlug}-${counter}`;
+    counter++;
+  }
+
+  // Get the next order value
+  const maxOrder = await prisma.workspace.aggregate({
+    _max: { order: true },
+  });
+  const order = data.order ?? (maxOrder._max.order ?? -1) + 1;
+
+  await prisma.workspace.create({
+    data: {
+      id: data.id,
+      name: data.name,
+      slug,
+      icon: data.icon,
+      emoji: data.emoji,
+      color: data.color,
+      order,
+      isDefault: data.isDefault ?? false,
+      isCloseable: data.isCloseable ?? true,
+    },
+  });
+
+  console.log(`[WS] Created workspace: ${data.name} (${slug})`);
+}
+
+async function handleWorkspaceDeleted(data: { workspaceId: string }): Promise<void> {
+  // Cascade delete will remove associated apps
+  await prisma.workspace.delete({
+    where: { id: data.workspaceId },
+  });
+
+  console.log(`[WS] Deleted workspace: ${data.workspaceId}`);
+}
+
+async function handleWorkspaceUpdated(data: WorkspaceData): Promise<void> {
+  // Only include fields that are explicitly provided (not undefined)
+  const updateData: Record<string, unknown> = {};
+  if (data.name !== undefined) updateData.name = data.name;
+  if (data.icon !== undefined) updateData.icon = data.icon;
+  if (data.emoji !== undefined) updateData.emoji = data.emoji || null;
+  if (data.color !== undefined) updateData.color = data.color || null;
+  if (data.order !== undefined) updateData.order = data.order;
+  if (data.isDefault !== undefined) updateData.isDefault = data.isDefault;
+  if (data.isCloseable !== undefined) updateData.isCloseable = data.isCloseable;
+
+  await prisma.workspace.update({
+    where: { id: data.id },
+    data: updateData,
+  });
+
+  console.log(`[WS] Updated workspace: ${data.id}`);
+}
+
+async function handleAppAdded(data: AppData): Promise<void> {
+  // Get the next zIndex for this workspace
+  const maxZ = await prisma.workspaceApp.aggregate({
+    where: { workspaceId: data.workspaceId },
+    _max: { zIndex: true },
+  });
+  const zIndex = data.zIndex ?? (maxZ._max.zIndex ?? 9) + 1;
+
+  await prisma.workspaceApp.create({
+    data: {
+      id: data.id,
+      workspaceId: data.workspaceId,
+      appType: data.appType,
+      x: data.x ?? 20,
+      y: data.y ?? 20,
+      width: data.width ?? 320,
+      height: data.height ?? 280,
+      zIndex,
+      isVisible: data.isVisible ?? true,
+      isLocked: data.isLocked ?? false,
+      config: data.config ? JSON.stringify(data.config) : null,
+    },
+  });
+
+  console.log(`[WS] Added app: ${data.appType} to workspace ${data.workspaceId}`);
+}
+
+async function handleAppRemoved(data: { appId: string }): Promise<void> {
+  await prisma.workspaceApp.delete({
+    where: { id: data.appId },
+  });
+
+  console.log(`[WS] Removed app: ${data.appId}`);
+}
+
+async function handleAppUpdated(data: AppUpdateData): Promise<void> {
+  const updateData: Record<string, unknown> = {};
+
+  if (data.x !== undefined) updateData.x = data.x;
+  if (data.y !== undefined) updateData.y = data.y;
+  if (data.width !== undefined) updateData.width = data.width;
+  if (data.height !== undefined) updateData.height = data.height;
+  if (data.zIndex !== undefined) updateData.zIndex = data.zIndex;
+  if (data.isVisible !== undefined) updateData.isVisible = data.isVisible;
+  if (data.isLocked !== undefined) updateData.isLocked = data.isLocked;
+  if (data.config !== undefined) updateData.config = JSON.stringify(data.config);
+
+  await prisma.workspaceApp.update({
+    where: { id: data.appId },
+    data: updateData,
+  });
+
+  console.log(`[WS] Updated app: ${data.appId}`);
+}
+
+async function handleWorkspaceSave(data: { workspaceId: string }): Promise<void> {
+  // Touch the updatedAt timestamp to indicate a save
+  await prisma.workspace.update({
+    where: { id: data.workspaceId },
+    data: { updatedAt: new Date() },
+  });
+
+  console.log(`[WS] Saved workspace: ${data.workspaceId}`);
+}
+
+async function handleWorkspaceImport(data: WorkspaceImportData): Promise<void> {
+  const { workspace, apps } = data;
+
+  // Create the workspace
+  await handleWorkspaceCreated(workspace);
+
+  // Create all apps
+  for (const app of apps) {
+    await handleAppAdded({
+      ...app,
+      workspaceId: workspace.id,
+    });
+  }
+
+  console.log(`[WS] Imported workspace: ${workspace.name} with ${apps.length} apps`);
+}
+
+/**
+ * Ensure a default "HOME" workspace exists
+ */
+export async function ensureDefaultWorkspace(): Promise<void> {
+  const existing = await prisma.workspace.findFirst({
+    where: { isDefault: true },
+  });
+
+  if (!existing) {
+    await prisma.workspace.create({
+      data: {
+        name: 'HOME',
+        slug: 'home',
+        icon: 'Home',
+        order: 0,
+        isDefault: true,
+        isCloseable: false,
+      },
+    });
+    console.log('[WS] Created default HOME workspace');
+  }
+}

package/start.sh

@@ -0,0 +1,170 @@
+#!/bin/bash
+
+# Start Aura Wallet - both server and UI
+
+MODE="${1:-dev}"  # Default to dev mode if no argument provided
+
+echo "Starting Aura Wallet in ${MODE} mode..."
+
+# Derive all service ports from a single dashboard port to avoid mismatches.
+# UI client derives wallet/ws ports from dashboard port at runtime.
+DASHBOARD_PORT="${DASHBOARD_PORT:-4747}"
+WALLET_PORT="$((DASHBOARD_PORT - 505))"
+WS_PORT_DERIVED="$((DASHBOARD_PORT + 1))"
+
+export DASHBOARD_PORT
+export WALLET_SERVER_PORT="$WALLET_PORT"
+export WS_PORT="$WS_PORT_DERIVED"
+
+# Track child processes for cleanup on failure/shutdown
+SERVER_PID=""
+CRON_PID=""
+UI_PID=""
+
+stop_processes() {
+  kill "$SERVER_PID" "$CRON_PID" "$UI_PID" 2>/dev/null
+}
+
+wait_for_health() {
+  local name="$1"
+  local url="$2"
+  local pid="$3"
+  local retries="${4:-40}"  # 40 * 0.5s = 20s default timeout
+
+  local i
+  for ((i=1; i<=retries; i++)); do
+    if curl -fsS "$url" >/dev/null 2>&1; then
+      return 0
+    fi
+
+    # If process died, fail immediately instead of waiting for timeout
+    if [ -n "$pid" ] && ! kill -0 "$pid" 2>/dev/null; then
+      echo "✗ ${name} exited before becoming healthy"
+      return 1
+    fi
+
+    sleep 0.5
+  done
+
+  echo "✗ ${name} did not become healthy at ${url}"
+  return 1
+}
+
+# Kill any existing processes
+pkill -f "tsx server/index.ts" 2>/dev/null
+pkill -f "tsx watch server/index.ts" 2>/dev/null
+pkill -f "tsx server/cron/index.ts" 2>/dev/null
+pkill -f "next dev" 2>/dev/null
+pkill -f "next start" 2>/dev/null
+
+if [ "$MODE" = "prod" ] || [ "$MODE" = "production" ]; then
+  # Production mode
+  echo "Building Next.js..."
+  npm run build
+
+  echo "Starting vault server on :4242..."
+  npm run server &
+  SERVER_PID=$!
+
+  if ! wait_for_health "Vault server" "http://127.0.0.1:${WALLET_PORT}/health" "$SERVER_PID" 80; then
+    echo "Vault server failed to start. Exiting."
+    stop_processes
+    exit 1
+  fi
+
+  echo "Starting cron server (balance sync, price sync)..."
+  npx tsx server/cron/index.ts &
+  CRON_PID=$!
+
+  echo "Starting Next.js production server on :${DASHBOARD_PORT}..."
+  npx next start -p "$DASHBOARD_PORT" &
+  UI_PID=$!
+
+  MODE_LABEL="PRODUCTION (API + dashboard)"
+else
+  # Development mode (default)
+  export BYPASS_RATE_LIMIT=true
+  # Keep internal docs visible in local dev unless explicitly overridden.
+  if [ -z "${NEXT_PUBLIC_SHOW_INTERNAL_DOCS}" ]; then
+    export NEXT_PUBLIC_SHOW_INTERNAL_DOCS=true
+  fi
+  echo "Internal docs visibility: NEXT_PUBLIC_SHOW_INTERNAL_DOCS=${NEXT_PUBLIC_SHOW_INTERNAL_DOCS}"
+
+  echo "Starting vault server (dev) on :${WALLET_PORT}..."
+  npm run server:dev &
+  SERVER_PID=$!
+
+  if ! wait_for_health "Vault server" "http://127.0.0.1:${WALLET_PORT}/health" "$SERVER_PID" 40; then
+    echo "server:dev failed, retrying vault server without watch mode..."
+    kill "$SERVER_PID" 2>/dev/null
+    BYPASS_RATE_LIMIT=true node --import tsx server/index.ts &
+    SERVER_PID=$!
+
+    if ! wait_for_health "Vault server" "http://127.0.0.1:${WALLET_PORT}/health" "$SERVER_PID" 40; then
+      echo "Vault server failed to start on :${WALLET_PORT}. Exiting."
+      stop_processes
+      exit 1
+    fi
+  fi
+
+  echo "Starting cron server (balance sync, price sync)..."
+  npx tsx server/cron/index.ts &
+  CRON_PID=$!
+
+  echo "Starting Next.js dev server on :${DASHBOARD_PORT}..."
+  npx next dev -p "$DASHBOARD_PORT" &
+  UI_PID=$!
+
+  MODE_LABEL="DEVELOPMENT (API + dashboard)"
+fi
+
+# Check if UI process exits immediately (most common startup failure mode)
+sleep 2
+if ! kill -0 "$UI_PID" 2>/dev/null; then
+  echo "✗ Next.js UI failed to start on :${DASHBOARD_PORT}"
+  stop_processes
+  exit 1
+fi
+
+# WebSocket sidecar is started by Next instrumentation. Warn if unavailable.
+if ! wait_for_health "WebSocket sidecar" "http://127.0.0.1:${WS_PORT_DERIVED}/health" "$UI_PID" 20; then
+  echo "⚠ WebSocket sidecar is not healthy on :${WS_PORT_DERIVED} yet; UI may show [WS] reconnect errors."
+fi
+
+# ── Startup summary ────────────────────────────────────────────
+if [ -t 1 ] && [ -z "$NO_COLOR" ] && [ "$CI" != "true" ] && [ "$TERM" != "dumb" ]; then
+  RST=$'\033[0m'; BOLD=$'\033[1m'; DIM=$'\033[2m'; GRAY=$'\033[90m'; CYAN=$'\033[38;5;154m'
+else
+  RST=''; BOLD=''; DIM=''; GRAY=''; CYAN=''
+fi
+
+PIPE="${GRAY}|${RST}"
+TL="${GRAY}.-${RST}"; TR="${GRAY}-.${RST}"
+BL="${GRAY}'-${RST}"; BR="${GRAY}-'${RST}"
+LP="${GRAY}|${RST}"
+LT="${GRAY}.${RST}${DIM}----------${RST}${GRAY}.${RST}"
+LB="${GRAY}'${RST}${DIM}----------${RST}${GRAY}'${RST}"
+PAD58=$(printf '%58s' '')
+PAD43=$(printf '%43s' '')
+PAD28=$(printf '%28s' '')
+
+echo ""
+echo "  ${TL}${DIM}${PAD58}${RST}${TR}"
+echo "  ${PIPE}   ${LT}${PAD43}${PIPE}"
+echo "  ${PIPE}   ${LP}${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}${LP}    ${BOLD}A U R A${RST}${PAD28}${PIPE}"
+echo "  ${PIPE}   ${LP}${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}${LP}    ${DIM}M A X X . S H${RST}                      ${PIPE}"
+echo "  ${PIPE}   ${LP}${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}  ${BOLD}\\\\${RST}${LP}    ${CYAN}STARTING${RST}                              ${PIPE}"
+echo "  ${PIPE}   ${LB}${PAD43}${PIPE}"
+echo "  ${BL}${DIM}${PAD58}${RST}${BR}"
+
+echo ""
+echo "    ${DIM}Mode            ${RST}${MODE_LABEL}"
+echo "    ${DIM}API (server)    ${RST}http://localhost:${WALLET_PORT}"
+echo "    ${DIM}Dashboard       ${RST}http://localhost:${DASHBOARD_PORT}"
+echo ""
+
+# Handle Ctrl+C - kill both processes
+trap "echo 'Shutting down...'; stop_processes; exit" SIGINT SIGTERM
+
+# Wait for either process to exit
+wait

package/tailwind.config.ts

@@ -0,0 +1,99 @@
+import type { Config } from "tailwindcss";
+
+const config: Config = {
+  content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  darkMode: ['selector', '[data-theme="dark"]'],
+  theme: {
+    extend: {
+      colors: {
+        // Legacy colors (preserved for backward compatibility)
+        voltage: '#ccff00',
+        void: '#0a0a0a',
+        tyvek: '#ffffff',
+        concrete: '#d4d4d8',
+        surgical: '#00f0ff',
+        alert: '#ff4d00',
+        'clinical-blue': '#0047ff',
+        'warning-orange': '#FF4D00',
+        'tyvek-dim': '#F0F0F0',
+        ink: '#050505',
+        signal: '#00FF41',
+
+        // Theme-aware colors using CSS variables
+        theme: {
+          accent: 'var(--color-accent, #ccff00)',
+          'accent-foreground': 'var(--color-accent-foreground, #0a0a0a)',
+          warning: 'var(--color-warning, #ff4d00)',
+          'warning-foreground': 'var(--color-warning-foreground, #ffffff)',
+          danger: 'var(--color-danger, #ef4444)',
+          'danger-foreground': 'var(--color-danger-foreground, #ffffff)',
+          success: 'var(--color-success, #00c853)',
+          'success-foreground': 'var(--color-success-foreground, #ffffff)',
+          info: 'var(--color-info, #0047ff)',
+          'info-foreground': 'var(--color-info-foreground, #ffffff)',
+          background: 'var(--color-background, #f5f5f5)',
+          'background-alt': 'var(--color-background-alt, #e8e8e6)',
+          surface: 'var(--color-surface, #ffffff)',
+          'surface-alt': 'var(--color-surface-alt, #fafafa)',
+          text: 'var(--color-text, #0a0a0a)',
+          'text-muted': 'var(--color-text-muted, #6b7280)',
+          'text-faint': 'var(--color-text-faint, #9ca3af)',
+          border: 'var(--color-border, #d4d4d8)',
+          'border-muted': 'var(--color-border-muted, #e5e5e5)',
+          'border-focus': 'var(--color-border-focus, #0a0a0a)',
+        },
+      },
+      fontFamily: {
+        sans: ['Inter', 'system-ui', 'sans-serif'],
+        mono: ['JetBrains Mono', 'Menlo', 'monospace'],
+      },
+      backgroundImage: {
+        'noise': "url('data:image/svg+xml,%3Csvg viewBox=\"0 0 200 200\" xmlns=\"http://www.w3.org/2000/svg\"%3E%3Cfilter id=\"noiseFilter\"%3E%3CfeTurbulence type=\"fractalNoise\" baseFrequency=\"0.9\" numOctaves=\"3\" stitchTiles=\"stitch\"/%3E%3C/filter%3E%3Crect width=\"100%25\" height=\"100%25\" filter=\"url(%23noiseFilter)\" opacity=\"0.05\"/%3E%3C/svg%3E')",
+        'grid-pattern': "linear-gradient(to right, #e5e5e5 1px, transparent 1px), linear-gradient(to bottom, #e5e5e5 1px, transparent 1px)",
+        'grid-pattern-dark': "linear-gradient(to right, rgba(255,255,255,0.06) 1px, transparent 1px), linear-gradient(to bottom, rgba(255,255,255,0.06) 1px, transparent 1px)",
+        'hazard-stripes': "repeating-linear-gradient(135deg, transparent, transparent 10px, rgba(204,255,0,0.06) 10px, rgba(204,255,0,0.06) 20px)",
+      },
+      animation: {
+        'slam': 'slam 0.4s cubic-bezier(0.19, 1, 0.22, 1) forwards',
+        'flash': 'flash 2s infinite',
+        'ticker': 'ticker 30s linear infinite',
+        'pulse-fast': 'pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+        'spin-slow': 'spin 3s linear infinite',
+        'scan-vertical': 'scan-vertical 3s linear infinite',
+        'app-focus': 'app-focus 0.25s cubic-bezier(0.34, 1.56, 0.64, 1)',
+      },
+      keyframes: {
+        slam: {
+          '0%': { transform: 'scale(1.05) translateY(20px)', opacity: '0' },
+          '100%': { transform: 'scale(1) translateY(0)', opacity: '1' },
+        },
+        ticker: {
+          '0%': { transform: 'translateX(0)' },
+          '100%': { transform: 'translateX(-100%)' },
+        },
+        flash: {
+          '0%, 100%': { opacity: '1' },
+          '50%': { opacity: '0.3' },
+        },
+        'scan-vertical': {
+          '0%': { top: '0', opacity: '0' },
+          '10%': { opacity: '1' },
+          '90%': { opacity: '1' },
+          '100%': { top: '100%', opacity: '0' },
+        },
+        'app-focus': {
+          '0%': { transform: 'scale(1)' },
+          '40%': { transform: 'scale(1.03)' },
+          '100%': { transform: 'scale(1)' },
+        }
+      }
+    },
+  },
+  plugins: [],
+};
+
+export default config;

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    },
+    "target": "ES2017"
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "server",
+    "extension"
+  ]
+}