vibecodingmachine-core 1.0.0

package/src/auth/shared-auth-storage.js

@@ -0,0 +1,230 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'allnightai');
+const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+const PROFILE_FILE = path.join(CONFIG_DIR, 'profile.json');
+const USAGE_FILE = path.join(CONFIG_DIR, 'usage.json');
+
+/**
+ * Shared authentication storage for both CLI and Electron
+ * Stores tokens and profiles in ~/.config/allnightai/
+ */
+class SharedAuthStorage {
+  /**
+   * Decode JWT token (simple base64 decode, no verification)
+   */
+  decodeJWT(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3) throw new Error('Invalid JWT');
+
+    const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+    return JSON.parse(payload);
+  }
+
+  /**
+   * Check if authenticated
+   */
+  async isAuthenticated() {
+    const token = await this.getToken();
+    if (!token) return false;
+
+    try {
+      // Decode JWT to check expiration
+      const payload = this.decodeJWT(token);
+      const now = Math.floor(Date.now() / 1000);
+
+      if (payload.exp && payload.exp > now) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get stored token
+   */
+  async getToken() {
+    try {
+      if (await fs.pathExists(TOKEN_FILE)) {
+        const data = await fs.readJson(TOKEN_FILE);
+        return data.token;
+      }
+    } catch (error) {
+      console.error('Failed to read token:', error);
+    }
+    return null;
+  }
+
+  /**
+   * Save token
+   */
+  async saveToken(token) {
+    await fs.ensureDir(CONFIG_DIR);
+    await fs.writeJson(TOKEN_FILE, { token }, { spaces: 2 });
+
+    // Also save user profile from token
+    try {
+      const payload = this.decodeJWT(token);
+      const email = payload.email;
+
+      // Note: Beta access control is handled server-side by Cognito Pre-Auth Lambda
+      // If we reached here, the user has already passed beta allowlist check
+
+      const profile = {
+        userId: payload.sub,
+        email: email,
+        name: payload.name || email,
+        picture: payload.picture,
+        tier: 'free', // Default, will be updated later
+        maxIterations: 10
+      };
+      await this.saveUserProfile(profile);
+    } catch (error) {
+      console.error('Failed to save user profile:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete token
+   */
+  async deleteToken() {
+    if (await fs.pathExists(TOKEN_FILE)) {
+      await fs.remove(TOKEN_FILE);
+    }
+    if (await fs.pathExists(PROFILE_FILE)) {
+      await fs.remove(PROFILE_FILE);
+    }
+  }
+
+  /**
+   * Get user profile
+   */
+  async getUserProfile() {
+    try {
+      if (await fs.pathExists(PROFILE_FILE)) {
+        return await fs.readJson(PROFILE_FILE);
+      }
+    } catch (error) {
+      console.error('Failed to read profile:', error);
+    }
+    return null;
+  }
+
+  /**
+   * Save user profile
+   */
+  async saveUserProfile(profile) {
+    await fs.ensureDir(CONFIG_DIR);
+    await fs.writeJson(PROFILE_FILE, profile, { spaces: 2 });
+  }
+
+  /**
+   * Check if user can run auto mode (quota check)
+   */
+  async canRunAutoMode() {
+    const token = await this.getToken();
+    if (!token) {
+      return { canRun: false, reason: 'Not authenticated' };
+    }
+
+    const profile = await this.getUserProfile();
+    if (!profile) {
+      return { canRun: false, reason: 'No user profile found' };
+    }
+
+    // Get today's usage from local tracking
+    const today = new Date().toISOString().split('T')[0];
+    let usage = 0;
+    try {
+      if (await fs.pathExists(USAGE_FILE)) {
+        const usageData = await fs.readJson(USAGE_FILE);
+        usage = usageData[today] || 0;
+      }
+    } catch (error) {
+      console.error('Error reading usage:', error);
+    }
+
+    // Check if user can run based on tier
+    const isPremium = profile.tier === 'premium';
+    const maxIterations = isPremium ? 999999 : (profile.maxIterations || 10);
+
+    if (!isPremium && usage >= maxIterations) {
+      return {
+        canRun: false,
+        reason: `Daily limit reached (${usage}/${maxIterations})`,
+        tier: profile.tier,
+        todayUsage: usage,
+        maxIterations: maxIterations
+      };
+    }
+
+    return {
+      canRun: true,
+      tier: profile.tier,
+      features: {
+        unlimitedIterations: isPremium,
+        cloudSync: isPremium,
+        mobileApp: isPremium
+      },
+      todayUsage: usage,
+      maxIterations: maxIterations
+    };
+  }
+
+  /**
+   * Log iteration (for quota tracking)
+   */
+  async logIteration() {
+    const today = new Date().toISOString().split('T')[0];
+
+    try {
+      await fs.ensureDir(CONFIG_DIR);
+
+      let usageData = {};
+      if (await fs.pathExists(USAGE_FILE)) {
+        usageData = await fs.readJson(USAGE_FILE);
+      }
+
+      usageData[today] = (usageData[today] || 0) + 1;
+
+      await fs.writeJson(USAGE_FILE, usageData, { spaces: 2 });
+      return true;
+    } catch (error) {
+      console.error('Error logging iteration:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Activate license key
+   */
+  async activateLicense(licenseKey) {
+    // TODO: Call backend API to validate and activate license
+    // For now, just upgrade to premium locally
+    const profile = await this.getUserProfile();
+    if (profile) {
+      profile.tier = 'premium';
+      profile.maxIterations = 999999;
+      profile.licenseKey = licenseKey;
+      await this.saveUserProfile(profile);
+      return { success: true, tier: 'premium' };
+    }
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  /**
+   * Logout
+   */
+  async logout() {
+    await this.deleteToken();
+    return true;
+  }
+}
+
+module.exports = new SharedAuthStorage();

package/src/autonomous-mode/feature-implementer.cjs

@@ -0,0 +1,70 @@
+// @vibecodingmachine/core - Feature Implementer (CommonJS) - Stub
+// Handles autonomous mode feature implementation and development workflow
+
+class FeatureImplementer {
+  constructor(options = {}) {
+    this.logger = options.logger || console;
+    this.electronAPI = options.electronAPI || null;
+    this.onStatusUpdate = options.onStatusUpdate || (() => {});
+    this.onProgressUpdate = options.onProgressUpdate || (() => {});
+    this.onMessageUpdate = options.onMessageUpdate || (() => {});
+    this.onErrorUpdate = options.onErrorUpdate || (() => {});
+    this.onCompleteUpdate = options.onCompleteUpdate || (() => {});
+  }
+
+  async startAutonomousMode(ide, tabId) {
+    this.logger.log('startAutonomousMode stub called for:', ide, tabId);
+    return {
+      success: true,
+      progress: 0,
+      completed: false,
+      taskCount: 0
+    };
+  }
+
+  stopAutonomousMode() {
+    this.logger.log('stopAutonomousMode stub');
+  }
+
+  pauseAutonomousMode() {
+    this.logger.log('pauseAutonomousMode stub');
+  }
+
+  resumeAutonomousMode() {
+    this.logger.log('resumeAutonomousMode stub');
+  }
+
+  getState() {
+    return {
+      isAutonomousMode: false,
+      isPaused: false,
+      isStopped: false,
+      currentProgress: 0,
+      taskCount: 0
+    };
+  }
+
+  setElectronAPI(electronAPI) {
+    this.electronAPI = electronAPI;
+  }
+
+  setCallbacks(callbacks) {
+    if (callbacks.onStatusUpdate) {
+      this.onStatusUpdate = callbacks.onStatusUpdate;
+    }
+    if (callbacks.onProgressUpdate) {
+      this.onProgressUpdate = callbacks.onProgressUpdate;
+    }
+    if (callbacks.onMessageUpdate) {
+      this.onMessageUpdate = callbacks.onMessageUpdate;
+    }
+    if (callbacks.onErrorUpdate) {
+      this.onErrorUpdate = callbacks.onErrorUpdate;
+    }
+    if (callbacks.onCompleteUpdate) {
+      this.onCompleteUpdate = callbacks.onCompleteUpdate;
+    }
+  }
+}
+
+module.exports = { FeatureImplementer };