vibemon 1.5.0

package/modules/validators.cjs

@@ -0,0 +1,180 @@
+/**
+ * Input validation functions for the Vibe Monitor
+ */
+
+const { VALID_STATES, CHARACTER_NAMES } = require('../shared/config.cjs');
+
+// Validation limits
+const PROJECT_MAX_LENGTH = 100;
+const TOOL_MAX_LENGTH = 50;
+const MODEL_MAX_LENGTH = 50;
+const TERMINAL_ID_MAX_LENGTH = 100;
+// Memory is now a number (0-100), not a string
+// iTerm2: w0t0p0:UUID format, Ghostty: numeric PID
+const ITERM2_SESSION_PATTERN = /^w\d+t\d+p\d+:[0-9A-Fa-f-]{36}$/;
+const GHOSTTY_PID_PATTERN = /^\d{1,10}$/;
+
+/**
+ * Validate state value
+ * @param {string} state
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateState(state) {
+  if (state === undefined) {
+    return { valid: true, error: null };
+  }
+  if (!VALID_STATES.includes(state)) {
+    return { valid: false, error: `Invalid state: ${state}. Valid states: ${VALID_STATES.join(', ')}` };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate character value
+ * @param {string} character
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateCharacter(character) {
+  if (character === undefined) {
+    return { valid: true, error: null };
+  }
+  if (!CHARACTER_NAMES.includes(character)) {
+    return { valid: false, error: `Invalid character: ${character}. Valid characters: ${CHARACTER_NAMES.join(', ')}` };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate project name
+ * @param {string} project
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateProject(project) {
+  if (project === undefined) {
+    return { valid: true, error: null };
+  }
+  if (typeof project !== 'string') {
+    return { valid: false, error: 'Project must be a string' };
+  }
+  if (project.length > PROJECT_MAX_LENGTH) {
+    return { valid: false, error: `Project name exceeds ${PROJECT_MAX_LENGTH} characters` };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate memory value (number 0-100)
+ * @param {number} memory
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateMemory(memory) {
+  if (memory === undefined || memory === null || memory === '') {
+    return { valid: true, error: null };
+  }
+  if (typeof memory !== 'number') {
+    return { valid: false, error: 'Memory must be a number' };
+  }
+  if (!Number.isInteger(memory) || memory < 0 || memory > 100) {
+    return { valid: false, error: 'Memory must be an integer between 0 and 100' };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate tool name
+ * @param {string} tool
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateTool(tool) {
+  if (tool === undefined || tool === '') {
+    return { valid: true, error: null };
+  }
+  if (typeof tool !== 'string') {
+    return { valid: false, error: 'Tool must be a string' };
+  }
+  if (tool.length > TOOL_MAX_LENGTH) {
+    return { valid: false, error: `Tool name exceeds ${TOOL_MAX_LENGTH} characters` };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate model name
+ * @param {string} model
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateModel(model) {
+  if (model === undefined || model === '') {
+    return { valid: true, error: null };
+  }
+  if (typeof model !== 'string') {
+    return { valid: false, error: 'Model must be a string' };
+  }
+  if (model.length > MODEL_MAX_LENGTH) {
+    return { valid: false, error: `Model name exceeds ${MODEL_MAX_LENGTH} characters` };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate terminal ID (iTerm2 session or Ghostty PID)
+ * @param {string} terminalId
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateTerminalId(terminalId) {
+  if (terminalId === undefined || terminalId === null || terminalId === '') {
+    return { valid: true, error: null };
+  }
+  if (typeof terminalId !== 'string') {
+    return { valid: false, error: 'terminalId must be a string' };
+  }
+  if (terminalId.length > TERMINAL_ID_MAX_LENGTH) {
+    return { valid: false, error: `terminalId exceeds ${TERMINAL_ID_MAX_LENGTH} characters` };
+  }
+  // Accept iTerm2 session format or Ghostty PID format
+  if (!ITERM2_SESSION_PATTERN.test(terminalId) && !GHOSTTY_PID_PATTERN.test(terminalId)) {
+    return { valid: false, error: 'terminalId must be a valid iTerm2 session ID or Ghostty PID' };
+  }
+  return { valid: true, error: null };
+}
+
+/**
+ * Validate status payload
+ * @param {object} data
+ * @returns {{valid: boolean, error: string|null}}
+ */
+function validateStatusPayload(data) {
+  const stateResult = validateState(data.state);
+  if (!stateResult.valid) return stateResult;
+
+  const characterResult = validateCharacter(data.character);
+  if (!characterResult.valid) return characterResult;
+
+  const projectResult = validateProject(data.project);
+  if (!projectResult.valid) return projectResult;
+
+  const memoryResult = validateMemory(data.memory);
+  if (!memoryResult.valid) return memoryResult;
+
+  const toolResult = validateTool(data.tool);
+  if (!toolResult.valid) return toolResult;
+
+  const modelResult = validateModel(data.model);
+  if (!modelResult.valid) return modelResult;
+
+  const terminalIdResult = validateTerminalId(data.terminalId);
+  if (!terminalIdResult.valid) return terminalIdResult;
+
+  return { valid: true, error: null };
+}
+
+module.exports = {
+  validateState,
+  validateCharacter,
+  validateProject,
+  validateMemory,
+  validateTool,
+  validateModel,
+  validateTerminalId,
+  validateStatusPayload
+};

package/modules/ws-client.cjs

@@ -0,0 +1,313 @@
+/**
+ * WebSocket client for Vibe Monitor
+ * Connects to a central server to receive real-time status updates
+ */
+
+const WebSocket = require('ws');
+const Store = require('electron-store');
+const { WS_URL, WS_TOKEN } = require('../shared/config.cjs');
+
+// Reconnection configuration
+const RECONNECT_INITIAL_DELAY = 5000;   // 5 seconds
+const RECONNECT_MAX_DELAY = 30000;      // 30 seconds
+const RECONNECT_MULTIPLIER = 1.5;
+
+class WsClient {
+  constructor() {
+    this.ws = null;
+    this.url = WS_URL;
+    this.reconnectDelay = RECONNECT_INITIAL_DELAY;
+    this.reconnectTimer = null;
+    this.isConnecting = false;
+    this.isConnected = false;
+    this.shouldReconnect = true;
+
+    // Persistent storage for token
+    this.store = new Store({
+      name: 'ws-settings',
+      defaults: {
+        token: null
+      }
+    });
+
+    // Load token: stored value > environment variable
+    const storedToken = this.store.get('token');
+    this.token = storedToken || WS_TOKEN || null;
+
+    // Callbacks
+    this.onStatusUpdate = null;  // Called when status message received
+    this.onConnectionChange = null;  // Called when connection state changes
+  }
+
+  /**
+   * Get current token
+   * @returns {string|null}
+   */
+  getToken() {
+    return this.token;
+  }
+
+  /**
+   * Set token and save to store
+   * @param {string|null} token
+   */
+  setToken(token) {
+    this.token = token || null;
+    this.store.set('token', this.token);
+
+    // Reconnect with new token (token is passed via URL query parameter)
+    if (this.isConnected || this.isConnecting) {
+      this.reconnect();
+    }
+  }
+
+  /**
+   * Reconnect to WebSocket server
+   */
+  reconnect() {
+    // Close current connection
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnecting = false;
+    this.isConnected = false;
+
+    // Clear any pending reconnect timer
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    // Reconnect immediately
+    this.reconnectDelay = RECONNECT_INITIAL_DELAY;
+    this.connect();
+  }
+
+  /**
+   * Clear token from store
+   */
+  clearToken() {
+    this.token = null;
+    this.store.delete('token');
+  }
+
+  /**
+   * Check if WebSocket is configured
+   * @returns {boolean}
+   */
+  isConfigured() {
+    return Boolean(this.url);
+  }
+
+  /**
+   * Get connection status
+   * @returns {string} 'connected', 'connecting', 'disconnected', or 'not-configured'
+   */
+  getStatus() {
+    if (!this.isConfigured()) {
+      return 'not-configured';
+    }
+    if (this.isConnected) {
+      return 'connected';
+    }
+    if (this.isConnecting) {
+      return 'connecting';
+    }
+    return 'disconnected';
+  }
+
+  /**
+   * Build connection URL with token as query parameter (like ESP32)
+   * @returns {string}
+   */
+  buildConnectionUrl() {
+    if (!this.token) {
+      return this.url;
+    }
+
+    // Add token as query parameter (same as ESP32: /?token=xxx)
+    const separator = this.url.includes('?') ? '&' : '?';
+    return `${this.url}${separator}token=${encodeURIComponent(this.token)}`;
+  }
+
+  /**
+   * Start WebSocket connection
+   */
+  connect() {
+    if (!this.isConfigured()) {
+      console.log('WebSocket not configured (VIBEMON_WS_URL not set)');
+      return;
+    }
+
+    if (this.isConnecting || this.isConnected) {
+      return;
+    }
+
+    this.isConnecting = true;
+    this.notifyConnectionChange();
+
+    const connectionUrl = this.buildConnectionUrl();
+    console.log(`WebSocket connecting to ${this.url}...`);
+
+    try {
+      this.ws = new WebSocket(connectionUrl);
+
+      this.ws.on('open', () => {
+        console.log('WebSocket connected');
+        this.isConnecting = false;
+        this.isConnected = true;
+        this.reconnectDelay = RECONNECT_INITIAL_DELAY;
+        this.notifyConnectionChange();
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleMessage(data);
+      });
+
+      this.ws.on('close', (code, reason) => {
+        console.log(`WebSocket closed: ${code} ${reason}`);
+        this.handleDisconnect();
+      });
+
+      this.ws.on('error', (error) => {
+        console.error('WebSocket error:', error.message);
+        // Error will be followed by close event
+      });
+    } catch (error) {
+      console.error('WebSocket connection error:', error.message);
+      this.handleDisconnect();
+    }
+  }
+
+  /**
+   * Send authentication message
+   */
+  sendAuth() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    const authMessage = JSON.stringify({
+      type: 'auth',
+      token: this.token
+    });
+
+    this.ws.send(authMessage);
+    console.log('WebSocket auth sent');
+  }
+
+  /**
+   * Handle incoming message
+   * @param {Buffer|string} data
+   */
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data.toString());
+
+      // Handle error messages from server
+      if (message.type === 'error') {
+        console.error('WebSocket server error:', message.message);
+        return;
+      }
+
+      // Handle auth success
+      if (message.type === 'authenticated') {
+        console.log('WebSocket authenticated, userId:', message.userId);
+        return;
+      }
+
+      // Handle status update (server sends {type: "status", data: {...}})
+      if (message.type === 'status' && message.data) {
+        if (this.onStatusUpdate) {
+          this.onStatusUpdate(message.data);
+        }
+        return;
+      }
+
+      // Handle status update (direct format: {state: "..."})
+      if (message.state) {
+        if (this.onStatusUpdate) {
+          this.onStatusUpdate(message);
+        }
+      }
+    } catch (error) {
+      console.error('WebSocket message parse error:', error.message);
+    }
+  }
+
+  /**
+   * Handle disconnection and schedule reconnect
+   */
+  handleDisconnect() {
+    this.isConnecting = false;
+    this.isConnected = false;
+    this.ws = null;
+    this.notifyConnectionChange();
+
+    if (this.shouldReconnect) {
+      this.scheduleReconnect();
+    }
+  }
+
+  /**
+   * Schedule reconnection with exponential backoff
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+
+    console.log(`WebSocket reconnecting in ${this.reconnectDelay / 1000}s...`);
+
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.reconnectDelay);
+
+    // Increase delay for next attempt (exponential backoff)
+    this.reconnectDelay = Math.min(
+      this.reconnectDelay * RECONNECT_MULTIPLIER,
+      RECONNECT_MAX_DELAY
+    );
+  }
+
+  /**
+   * Notify connection state change
+   */
+  notifyConnectionChange() {
+    if (this.onConnectionChange) {
+      this.onConnectionChange(this.getStatus());
+    }
+  }
+
+  /**
+   * Disconnect and stop reconnection
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
+    this.isConnecting = false;
+    this.isConnected = false;
+    this.notifyConnectionChange();
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.disconnect();
+  }
+}
+
+module.exports = { WsClient };

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "vibemon",
+  "version": "1.5.0",
+  "description": "AI assistant status monitor",
+  "main": "main.js",
+  "bin": {
+    "vibemon": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "electron .",
+    "build": "electron-builder",
+    "build:mac": "electron-builder --mac",
+    "build:dmg": "electron-builder --mac dmg",
+    "build:win": "electron-builder --win",
+    "build:linux": "electron-builder --linux",
+    "build:all": "electron-builder --mac --win --linux",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "author": "nalbam",
+  "license": "MIT",
+  "keywords": [
+    "vibemon",
+    "claude-code",
+    "kiro",
+    "ai-assistant",
+    "status-monitor",
+    "electron",
+    "pixel-art"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nalbam/vibemon-app.git"
+  },
+  "homepage": "https://nalbam.github.io/vibemon-app/",
+  "bugs": {
+    "url": "https://github.com/nalbam/vibemon-app/issues"
+  },
+  "dependencies": {
+    "canvas": "^3.2.1",
+    "dotenv": "^17.2.3",
+    "electron": "^33.0.0",
+    "electron-store": "^8.2.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "electron-builder": "^25.0.0",
+    "eslint": "^9.0.0",
+    "jest": "^29.7.0"
+  },
+  "files": [
+    "README.md",
+    "bin/",
+    "main.js",
+    "preload.js",
+    "index.html",
+    "stats.html",
+    "renderer.js",
+    "styles.css",
+    "assets/",
+    "modules/",
+    "shared/"
+  ],
+  "build": {
+    "appId": "com.nalbam.vibemon",
+    "productName": "VibeMon",
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "icon": "assets/icon.icns",
+      "target": [
+        "dmg",
+        "zip"
+      ]
+    },
+    "win": {
+      "icon": "assets/icon.ico",
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "portable",
+          "arch": [
+            "x64"
+          ]
+        }
+      ]
+    },
+    "nsis": {
+      "oneClick": false,
+      "perMachine": false,
+      "allowToChangeInstallationDirectory": true,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true
+    },
+    "linux": {
+      "icon": "assets/icon.png",
+      "target": [
+        "AppImage",
+        "deb"
+      ],
+      "category": "Development"
+    }
+  }
+}

package/preload.js

@@ -0,0 +1,22 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronAPI', {
+  closeWindow: () => ipcRenderer.send('close-window'),
+  minimizeWindow: () => ipcRenderer.send('minimize-window'),
+  showContextMenu: () => ipcRenderer.send('show-context-menu'),
+  focusTerminal: () => ipcRenderer.invoke('focus-terminal'),
+  onStateUpdate: (callback) => {
+    const handler = (_event, data) => {
+      try {
+        callback(data);
+      } catch (error) {
+        console.error('State update callback error:', error);
+      }
+    };
+    ipcRenderer.on('state-update', handler);
+    // Return cleanup function to prevent memory leaks
+    return () => ipcRenderer.removeListener('state-update', handler);
+  },
+  getVersion: () => ipcRenderer.invoke('get-version'),
+  getPlatform: () => process.platform
+});

package/renderer.js

@@ -0,0 +1,84 @@
+import { createVibeMonEngine } from 'https://static.vibemon.io/js/vibemon-engine-standalone.js';
+
+// Static server base URL
+const STATIC_BASE = 'https://static.vibemon.io';
+
+// VibeMon engine instance
+let vibeMonEngine = null;
+
+// IPC cleanup function
+let cleanupStateListener = null;
+
+// Initialize
+async function init() {
+  const container = document.getElementById('vibemon-display');
+
+  // Get platform info for emoji detection
+  let useEmoji = false;
+  if (window.electronAPI?.getPlatform) {
+    const platform = window.electronAPI.getPlatform();
+    useEmoji = platform === 'darwin';
+  }
+
+  // Create and initialize VibeMon engine with static server images
+  vibeMonEngine = createVibeMonEngine(container, {
+    useEmoji,
+    characterImageUrls: {
+      apto: `${STATIC_BASE}/characters/apto.png`,
+      clawd: `${STATIC_BASE}/characters/clawd.png`,
+      kiro: `${STATIC_BASE}/characters/kiro.png`,
+      claw: `${STATIC_BASE}/characters/claw.png`
+    }
+  });
+  await vibeMonEngine.init();
+
+  // Initial render and start animation
+  vibeMonEngine.render();
+  vibeMonEngine.startAnimation();
+
+  // Listen for state updates from main process
+  if (window.electronAPI) {
+    cleanupStateListener = window.electronAPI.onStateUpdate((data) => {
+      // Validate incoming data
+      if (!data || typeof data !== 'object') return;
+
+      // Update state in VibeMon engine
+      vibeMonEngine.setState(data);
+      vibeMonEngine.render();
+    });
+  }
+
+  // Right-click context menu (works on all platforms)
+  document.addEventListener('contextmenu', (e) => {
+    e.preventDefault();
+    if (window.electronAPI?.showContextMenu) {
+      window.electronAPI.showContextMenu();
+    }
+  });
+
+  // Click to focus terminal (iTerm2/Ghostty on macOS)
+  document.addEventListener('click', (e) => {
+    // Ignore right-click
+    if (e.button !== 0) return;
+    if (window.electronAPI?.focusTerminal) {
+      window.electronAPI.focusTerminal();
+    }
+  });
+}
+
+// Cleanup on unload
+function cleanup() {
+  if (vibeMonEngine) {
+    vibeMonEngine.cleanup();
+    vibeMonEngine = null;
+  }
+  if (cleanupStateListener) {
+    cleanupStateListener();
+    cleanupStateListener = null;
+  }
+}
+
+// Initialize on load
+window.onload = init;
+window.onbeforeunload = cleanup;
+window.onunload = cleanup;