vibecodingmachine-core 1.0.0

package/src/ui/StateManager.js

@@ -0,0 +1,259 @@
+/**
+ * Shared State Manager
+ * Manages state synchronization between electron app and VSCode extension
+ */
+
+class StateManager {
+  constructor() {
+    this.state = {
+      autonomousMode: false,
+      isPaused: false,
+      isStopped: false,
+      isCheckingQuota: false,
+      isOpeningIde: false,
+      currentIde: 'vscode', // Default IDE
+      featureProgress: 0,
+      currentFeature: null,
+      status: 'Ready to chat',
+      messages: [],
+      tabs: [],
+      activeTabId: null
+    };
+
+    this.listeners = new Set();
+    this.storageKey = 'allnightai-shared-state';
+  }
+
+  // Get current state
+  getState() {
+    return { ...this.state };
+  }
+
+  // Update state and notify listeners
+  setState(updates) {
+    const oldState = { ...this.state };
+    this.state = { ...this.state, ...updates };
+
+    // Save to localStorage for persistence
+    this.saveToStorage();
+
+    // Notify all listeners
+    this.listeners.forEach(listener => {
+      try {
+        listener(this.state, oldState);
+      } catch (error) {
+        console.error('State listener error:', error);
+      }
+    });
+  }
+
+  // Subscribe to state changes
+  subscribe(listener) {
+    this.listeners.add(listener);
+
+    // Return unsubscribe function
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  // Save state to localStorage
+  saveToStorage() {
+    try {
+      localStorage.setItem(this.storageKey, JSON.stringify(this.state));
+    } catch (error) {
+      console.error('Failed to save state to storage:', error);
+    }
+  }
+
+  // Load state from localStorage
+  loadFromStorage() {
+    try {
+      const saved = localStorage.getItem(this.storageKey);
+      if (saved) {
+        const parsed = JSON.parse(saved);
+        this.setState(parsed);
+      }
+    } catch (error) {
+      console.error('Failed to load state from storage:', error);
+    }
+  }
+
+  // Autonomous mode actions
+  startAutonomousMode(ide) {
+    this.setState({
+      autonomousMode: true,
+      isPaused: false,
+      isStopped: false,
+      currentIde: ide,
+      status: 'Starting autonomous mode...',
+      featureProgress: 0
+    });
+  }
+
+  stopAutonomousMode() {
+    this.setState({
+      autonomousMode: false,
+      isPaused: false,
+      isStopped: true,
+      status: 'Autonomous mode stopped',
+      featureProgress: 0,
+      currentFeature: null
+    });
+  }
+
+  pauseAutonomousMode() {
+    this.setState({
+      isPaused: true,
+      status: 'Autonomous mode paused'
+    });
+  }
+
+  resumeAutonomousMode() {
+    this.setState({
+      isPaused: false,
+      status: 'Autonomous mode resumed'
+    });
+  }
+
+  togglePause() {
+    if (this.state.isPaused) {
+      this.resumeAutonomousMode();
+    } else {
+      this.pauseAutonomousMode();
+    }
+  }
+
+  // Quota checking
+  startQuotaCheck() {
+    this.setState({
+      isCheckingQuota: true,
+      status: 'Checking quota...'
+    });
+  }
+
+  finishQuotaCheck(result) {
+    this.setState({
+      isCheckingQuota: false,
+      status: result.success ? 'Quota check completed' : 'Quota check failed'
+    });
+  }
+
+  // IDE opening
+  startOpeningIde() {
+    this.setState({
+      isOpeningIde: true,
+      status: 'Opening IDE...'
+    });
+  }
+
+  finishOpeningIde(result) {
+    this.setState({
+      isOpeningIde: false,
+      status: result.success ? 'IDE opened successfully' : 'Failed to open IDE'
+    });
+  }
+
+  // Feature progress
+  updateFeatureProgress(progress, feature = null) {
+    this.setState({
+      featureProgress: progress,
+      currentFeature: feature,
+      status: `Autonomous mode progress: ${progress}%`
+    });
+  }
+
+  // Message management
+  addMessage(role, text) {
+    const message = {
+      id: Date.now(),
+      role,
+      text,
+      timestamp: new Date().toISOString()
+    };
+
+    this.setState({
+      messages: [...this.state.messages, message]
+    });
+  }
+
+  clearMessages() {
+    this.setState({
+      messages: []
+    });
+  }
+
+  // Tab management
+  setTabs(tabs) {
+    this.setState({
+      tabs,
+      activeTabId: tabs.length > 0 ? tabs[0].id : null
+    });
+  }
+
+  setActiveTab(tabId) {
+    this.setState({
+      activeTabId: tabId
+    });
+  }
+
+  // Status updates
+  updateStatus(status) {
+    this.setState({
+      status
+    });
+  }
+
+  // Reset state
+  reset() {
+    this.setState({
+      autonomousMode: false,
+      isPaused: false,
+      isStopped: false,
+      isCheckingQuota: false,
+      isOpeningIde: false,
+      currentIde: 'vscode', // Default IDE
+      featureProgress: 0,
+      currentFeature: null,
+      status: 'Ready to chat',
+      messages: [],
+      tabs: [],
+      activeTabId: null
+    });
+  }
+
+  // Get specific state values
+  isAutonomousMode() {
+    return this.state.autonomousMode;
+  }
+
+  isPaused() {
+    return this.state.isPaused;
+  }
+
+  isStopped() {
+    return this.state.isStopped;
+  }
+
+  getCurrentIde() {
+    return this.state.currentIde;
+  }
+
+  getStatus() {
+    return this.state.status;
+  }
+
+  getProgress() {
+    return this.state.featureProgress;
+  }
+}
+
+// Create singleton instance
+const stateManager = new StateManager();
+
+// Load initial state from storage
+if (typeof window !== 'undefined') {
+  stateManager.loadFromStorage();
+}
+
+export { StateManager, stateManager };

package/src/utils/audit-logger.cjs

@@ -0,0 +1,116 @@
+// Shared audit logger for both Electron app and CLI
+const fs = require('fs');
+const path = require('path');
+
+function getDateStr(d = new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+function getAuditLogDir() {
+  return path.join(process.cwd(), 'logs', 'audit');
+}
+
+function ensureAuditLogDir() {
+  const dir = getAuditLogDir();
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch (_) {}
+  return dir;
+}
+
+function appendAuditLog(entry) {
+  try {
+    const dir = ensureAuditLogDir();
+    const when = entry && entry.timestamp ? new Date(entry.timestamp) : new Date();
+    const dateStr = getDateStr(when);
+    const filePath = path.join(dir, `${dateStr}.jsonl`);
+    const line = JSON.stringify(entry) + '\n';
+    fs.appendFileSync(filePath, line);
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+function listAuditLogDates() {
+  try {
+    const dir = getAuditLogDir();
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => f.replace(/\.jsonl$/, ''))
+      .sort();
+  } catch (e) {
+    return [];
+  }
+}
+
+function readAuditLog(dateStr) {
+  try {
+    const dir = getAuditLogDir();
+    const filePath = path.join(dir, `${dateStr}.jsonl`);
+    if (!fs.existsSync(filePath)) return [];
+    const data = fs.readFileSync(filePath, 'utf8');
+    return data.split('\n').filter(Boolean).map(line => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
+function logAutoModeStart(ide, maxChats) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    type: 'auto-mode-start',
+    ide,
+    maxChats,
+    message: `Auto Mode started with ${ide}, max chats: ${maxChats === 0 ? 'unlimited' : maxChats}`
+  };
+  appendAuditLog(entry);
+  return entry;
+}
+
+function logAutoModeStop(reason = 'manual') {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    type: 'auto-mode-stop',
+    reason,
+    message: `Auto Mode stopped (${reason})`
+  };
+  appendAuditLog(entry);
+  return entry;
+}
+
+function logIDEMessage(ide, message, truncate = 100) {
+  const displayMessage = message.length > truncate
+    ? message.substring(0, truncate) + '...'
+    : message;
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    type: 'ide-message',
+    ide,
+    message: displayMessage,
+    fullMessage: message
+  };
+  appendAuditLog(entry);
+  return entry;
+}
+
+module.exports = {
+  appendAuditLog,
+  listAuditLogDates,
+  readAuditLog,
+  logAutoModeStart,
+  logAutoModeStop,
+  logIDEMessage,
+  getDateStr
+};

package/src/utils/config-helpers.cjs

@@ -0,0 +1,94 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+
+/**
+ * Get the config directory path
+ * Uses the same location as Electron's app.getPath('userData')
+ * @returns {string} The config directory path
+ */
+function getConfigDir() {
+  const platform = process.platform;
+  const home = os.homedir();
+
+  let configDir;
+  if (platform === 'darwin') {
+    // macOS: ~/Library/Application Support/allnightai
+    configDir = path.join(home, 'Library', 'Application Support', 'allnightai');
+  } else if (platform === 'win32') {
+    // Windows: %APPDATA%\allnightai
+    configDir = path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'allnightai');
+  } else {
+    // Linux: ~/.config/allnightai
+    configDir = path.join(home, '.config', 'allnightai');
+  }
+
+  return configDir;
+}
+
+/**
+ * Get the config file path
+ * @returns {string} The config file path
+ */
+function getConfigPath() {
+  return path.join(getConfigDir(), 'allnightai-config.json');
+}
+
+/**
+ * Load the config from disk
+ * @returns {Promise<Object>} The config object
+ */
+async function loadConfig() {
+  try {
+    const configPath = getConfigPath();
+    if (await fs.pathExists(configPath)) {
+      return await fs.readJson(configPath);
+    }
+  } catch (error) {
+    // Ignore errors, return empty config
+  }
+  return {};
+}
+
+/**
+ * Save the config to disk
+ * @param {Object} config - The config object to save
+ * @returns {Promise<void>}
+ */
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await fs.ensureDir(path.dirname(configPath));
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+/**
+ * Get a config value
+ * @param {string} key - The config key
+ * @param {*} defaultValue - The default value if key doesn't exist
+ * @returns {Promise<*>} The config value
+ */
+async function getConfigValue(key, defaultValue = null) {
+  const config = await loadConfig();
+  return config[key] !== undefined ? config[key] : defaultValue;
+}
+
+/**
+ * Set a config value
+ * @param {string} key - The config key
+ * @param {*} value - The value to set
+ * @returns {Promise<void>}
+ */
+async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+module.exports = {
+  getConfigDir,
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue
+};

package/src/utils/config-helpers.js

@@ -0,0 +1,94 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+
+/**
+ * Get the config directory path
+ * Uses the same location as Electron's app.getPath('userData')
+ * @returns {string} The config directory path
+ */
+function getConfigDir() {
+  const platform = process.platform;
+  const home = os.homedir();
+
+  let configDir;
+  if (platform === 'darwin') {
+    // macOS: ~/Library/Application Support/allnightai
+    configDir = path.join(home, 'Library', 'Application Support', 'allnightai');
+  } else if (platform === 'win32') {
+    // Windows: %APPDATA%\allnightai
+    configDir = path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'allnightai');
+  } else {
+    // Linux: ~/.config/allnightai
+    configDir = path.join(home, '.config', 'allnightai');
+  }
+
+  return configDir;
+}
+
+/**
+ * Get the config file path
+ * @returns {string} The config file path
+ */
+function getConfigPath() {
+  return path.join(getConfigDir(), 'allnightai-config.json');
+}
+
+/**
+ * Load the config from disk
+ * @returns {Promise<Object>} The config object
+ */
+async function loadConfig() {
+  try {
+    const configPath = getConfigPath();
+    if (await fs.pathExists(configPath)) {
+      return await fs.readJson(configPath);
+    }
+  } catch (error) {
+    // Ignore errors, return empty config
+  }
+  return {};
+}
+
+/**
+ * Save the config to disk
+ * @param {Object} config - The config object to save
+ * @returns {Promise<void>}
+ */
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await fs.ensureDir(path.dirname(configPath));
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+/**
+ * Get a config value
+ * @param {string} key - The config key
+ * @param {*} defaultValue - The default value if key doesn't exist
+ * @returns {Promise<*>} The config value
+ */
+async function getConfigValue(key, defaultValue = null) {
+  const config = await loadConfig();
+  return config[key] !== undefined ? config[key] : defaultValue;
+}
+
+/**
+ * Set a config value
+ * @param {string} key - The config key
+ * @param {*} value - The value to set
+ * @returns {Promise<void>}
+ */
+async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+module.exports = {
+  getConfigDir,
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue
+};

package/src/utils/electron-update-checker.js

@@ -0,0 +1,78 @@
+const https = require('https');
+
+/**
+ * Check for Electron app updates from S3 version manifest
+ * @param {string} currentVersion - Current version (e.g., '1.0.0')
+ * @returns {Promise<Object>} Update info or null if no update available
+ */
+async function checkForElectronUpdates(currentVersion) {
+  return new Promise((resolve, reject) => {
+    const manifestUrl = 'https://vibecodingmachine-website.s3.amazonaws.com/version-manifest.json';
+
+    https.get(manifestUrl, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const manifest = JSON.parse(data);
+          const latestVersion = manifest.version;
+
+          if (latestVersion !== currentVersion) {
+            const publishedDate = new Date(manifest.publishedDate);
+
+            // Detect architecture and choose appropriate download URL
+            // For auto-updates, use architecture-specific builds (faster, smaller)
+            const arch = process.arch; // 'arm64' or 'x64'
+            let downloadUrl = manifest.downloadUrl; // Fallback to universal
+
+            if (arch === 'arm64' && manifest.downloadUrlArm64) {
+              downloadUrl = manifest.downloadUrlArm64;
+              console.log('✅ Using Apple Silicon optimized update');
+            } else if (arch === 'x64' && manifest.downloadUrlX64) {
+              downloadUrl = manifest.downloadUrlX64;
+              console.log('✅ Using Intel optimized update');
+            } else {
+              console.log('ℹ️ Using universal build for update');
+            }
+
+            resolve({
+              hasUpdate: true,
+              currentVersion,
+              latestVersion,
+              publishedDate: publishedDate.toLocaleString('en-US', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                timeZoneName: 'short'
+              }),
+              downloadUrl,
+              releaseNotes: manifest.releaseNotes || ''
+            });
+          } else {
+            resolve({
+              hasUpdate: false,
+              currentVersion,
+              latestVersion
+            });
+          }
+        } catch (error) {
+          console.error('Error parsing version manifest:', error);
+          resolve({ hasUpdate: false, currentVersion, error: error.message });
+        }
+      });
+    }).on('error', (error) => {
+      console.error('Error checking for Electron updates:', error);
+      resolve({ hasUpdate: false, currentVersion, error: error.message });
+    });
+  });
+}
+
+module.exports = {
+  checkForElectronUpdates
+};