klio 1.4.9 → 1.5.1

package/src/gui/server.js

@@ -1,30 +1,80 @@
 const express = require('express');
 const path = require('path');
 const apiRouter = require('./routes/api');
-const commandDatabase = require('./database');
+const session = require('express-session');
+const FileStore = require('session-file-store')(session);
 
 class GUIServer {
   constructor() {
     this.app = express();
     this.server = null;
-    this.port = 37421; // Less common port
+    const envPort = parseInt(process.env.PORT, 10);
+    this.port = Number.isFinite(envPort) ? envPort : 37421; // Less common port
+    this.verboseLogging = false; // Default to minimal logging
   }
 
   async initialize() {
-    // Initialize database
-    await commandDatabase.initialize();
+    // Session configuration
+    const sessionStore = new FileStore();
+    
+    this.app.use(session({
+      secret: 'astrocli-secret-key-change-in-production',
+      resave: false,
+      saveUninitialized: true,
+      store: sessionStore,
+      cookie: {
+        secure: false, // Set to true if using HTTPS
+        maxAge: 24 * 60 * 60 * 1000, // 1 day
+        httpOnly: true
+      }
+    }));
 
     // Middleware
     this.app.use(express.json());
     this.app.use(express.urlencoded({ extended: true }));
 
+    // Session middleware to set default user
+    this.app.use((req, res, next) => {
+      if (!req.session.userId) {
+        // Generate a unique user ID for new sessions
+        req.session.userId = 'user-' + Math.random().toString(36).substr(2, 9);
+        if (this.verboseLogging) {
+          console.log(`👤 New user session created: ${req.session.userId}`);
+        }
+      }
+      next();
+    });
+
     // API routes
     this.app.use('/api', apiRouter);
 
+    // Add security headers for cross-origin isolation (required for WebContainers)
+    this.app.use((req, res, next) => {
+      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+      
+      // Add debug header to verify headers are being set
+      if (this.verboseLogging) {
+        console.log('🔒 Setting cross-origin isolation headers');
+      }
+      
+      // Add warning about HTTPS requirement
+      if (this.verboseLogging && req.protocol !== 'https') {
+        console.warn('⚠️ Cross-origin isolation headers require HTTPS in production. For development, use localhost or configure HTTPS.');
+      }
+      
+      next();
+    });
+
     // Serve static files from public directory
     this.app.use(express.static(path.join(__dirname, 'public')));
 
-    // Serve index.html for all other routes (for SPA behavior)
+    // Serve index.html as the main interface
+    this.app.get('/', (req, res) => {
+      res.sendFile(path.join(__dirname, 'public', 'index.html'));
+    });
+
+    // Serve index.html for other routes (for backward compatibility)
     this.app.get('*', (req, res) => {
       res.sendFile(path.join(__dirname, 'public', 'index.html'));
     });
@@ -36,12 +86,23 @@ class GUIServer {
     });
   }
 
+  // Method to enable verbose logging
+  enableVerboseLogging(enable = true) {
+    this.verboseLogging = enable;
+  }
+
   start(port = this.port) {
     return new Promise((resolve, reject) => {
-      this.server = this.app.listen(port, () => {
-        console.log(`🌐 GUI Server running on http://localhost:${port}`);
-        console.log(`📊 Command history available at http://localhost:${port}`);
-        console.log('💡 Press Ctrl+C to stop the server');
+      this.server = this.app.listen(port, '0.0.0.0', () => {
+        if (this.verboseLogging) {
+          console.log(`🌐 GUI Server running on http://localhost:${port}`);
+          console.log(`📊 Command history available at http://localhost:${port}`);
+          console.log('💡 Press Ctrl+C to stop the server');
+        } else {
+          console.log(`🌐 GUI Server started successfully!`);
+          console.log(`📊 Open your browser and navigate to: http://localhost:${port}`);
+          console.log(`💡 Press Ctrl+C to stop the server and return to CLI`);
+        }
         resolve();
       });
 
@@ -55,28 +116,16 @@ class GUIServer {
       });
     });
   }
+}
 
-  async stop() {
-    return new Promise((resolve, reject) => {
-      if (this.server) {
-        this.server.close(async () => {
-          await commandDatabase.close();
-          console.log('GUI Server stopped');
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
+module.exports = new GUIServer();
 
-  getPort() {
-    if (this.server) {
-      const address = this.server.address();
-      return address && address.port;
-    }
-    return this.port;
-  }
+if (require.main === module) {
+  const server = module.exports;
+  server.initialize()
+    .then(() => server.start())
+    .catch((err) => {
+      console.error('Failed to start GUI server:', err);
+      process.exit(1);
+    });
 }
-
-module.exports = new GUIServer();

package/src/gui/webcontainerSetup.js

@@ -0,0 +1,244 @@
+// WebContainer Setup Module
+// This module provides server-side functionality for WebContainer file management
+
+const fs = require('fs');
+const path = require('path');
+
+class WebContainerSetup {
+  constructor() {
+    this.projectRoot = path.resolve(__dirname, '..', '..');
+  }
+
+  // Get project files for WebContainer
+  async getProjectFiles() {
+    try {
+      const files = {};
+      
+      // Read package.json
+      const packageJsonPath = path.join(this.projectRoot, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const rawPackageJson = fs.readFileSync(packageJsonPath, 'utf8');
+        try {
+          const parsed = JSON.parse(rawPackageJson);
+          const minimalDependencies = {
+            commander: '^14.0.3',
+            'moment-timezone': '^0.6.0',
+            axios: '^1.13.4',
+            'csv-parser': '^3.0.0',
+            'csv-parse': '^5.5.6',
+            'fast-xml-parser': '^5.3.4'
+          };
+
+          const webPackageJson = {
+            name: parsed.name || 'klio-web',
+            version: parsed.version || '0.0.0',
+            description: parsed.description || 'Klio WebContainer runtime',
+            type: parsed.type || 'commonjs',
+            dependencies: minimalDependencies
+          };
+
+          files['package.json'] = JSON.stringify(webPackageJson, null, 2);
+        } catch (error) {
+          files['package.json'] = rawPackageJson;
+        }
+      }
+      
+      // Read main entry file
+      const mainFilePath = path.join(this.projectRoot, 'index.js');
+      if (fs.existsSync(mainFilePath)) {
+        files['index.js'] = fs.readFileSync(mainFilePath, 'utf8');
+      }
+      
+      // Read src directory files
+      const srcDir = path.join(this.projectRoot, 'src');
+      if (fs.existsSync(srcDir)) {
+        this._readDirectory(srcDir, 'src/', files);
+      }
+
+      // Read Sweph WASM assets
+      const swephDir = path.join(this.projectRoot, 'src', 'gui', 'public', 'sweph');
+      if (fs.existsSync(swephDir)) {
+        this._readDirectory(swephDir, 'src/gui/public/sweph/', files);
+      }
+      
+      // Create webcontainer-entry.js for command execution
+      files['webcontainer-entry.js'] = this._createWebContainerEntry();
+      
+      return files;
+      
+    } catch (error) {
+      console.error('Error getting project files:', error);
+      throw error;
+    }
+  }
+
+  // Read directory recursively
+  _readDirectory(dirPath, relativePath, files) {
+    const items = fs.readdirSync(dirPath);
+    
+    for (const item of items) {
+      const fullPath = path.join(dirPath, item);
+      const itemRelativePath = path.join(relativePath, item);
+      
+      if (fs.statSync(fullPath).isDirectory()) {
+        // Skip node_modules and other large directories
+        if (item === 'node_modules' || item === '.git' || item === 'ephe') {
+          continue;
+        }
+        this._readDirectory(fullPath, itemRelativePath, files);
+      } else {
+        // Skip large files and binary files
+        if (item.endsWith('.db') || item.endsWith('.json') && item !== 'package.json') {
+          continue;
+        }
+        
+        try {
+          if (item.endsWith('.wasm') || item.endsWith('.data')) {
+            const content = fs.readFileSync(fullPath);
+            files[itemRelativePath] = {
+              encoding: 'base64',
+              contents: content.toString('base64')
+            };
+          } else {
+            const content = fs.readFileSync(fullPath, 'utf8');
+            files[itemRelativePath] = content;
+          }
+        } catch (error) {
+          console.warn(`Skipping file ${itemRelativePath}: ${error.message}`);
+        }
+      }
+    }
+  }
+
+  // Create WebContainer entry file
+  _createWebContainerEntry() {
+    return `// WebContainer Entry Point
+// Executes CLI commands using the WebContainer-compatible service.
+
+const fs = require('fs');
+const path = require('path');
+
+const findFile = (startDir, target, maxDepth = 5) => {
+  if (maxDepth < 0) {
+    return null;
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(startDir, { withFileTypes: true });
+  } catch (error) {
+    return null;
+  }
+
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+      continue;
+    }
+
+    const fullPath = path.join(startDir, entry.name);
+    if (entry.isDirectory()) {
+      const found = findFile(fullPath, target, maxDepth - 1);
+      if (found) {
+        return found;
+      }
+    } else if (entry.isFile() && entry.name === target) {
+      return fullPath;
+    }
+  }
+
+  return null;
+};
+
+const loadCliService = () => {
+  const candidates = [
+    path.resolve(process.cwd(), 'src', 'cli', 'cliService.js'),
+    path.resolve(process.cwd(), 'cli', 'cliService.js'),
+    path.resolve(__dirname, 'src', 'cli', 'cliService.js'),
+    '/src/cli/cliService.js',
+    path.resolve(__dirname, 'src', 'cli', 'cliService'),
+    path.resolve(__dirname, 'cli', 'cliService.js'),
+    '/cli/cliService.js'
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return require(candidate);
+    }
+  }
+
+  const searched = findFile(process.cwd(), 'cliService.js');
+  if (searched) {
+    return require(searched);
+  }
+
+  throw new Error('CLI service not found. Checked: ' + candidates.join(', ') + '. Searched from: ' + process.cwd());
+};
+
+const loadSwephAdapter = () => {
+  const candidates = [
+    path.resolve(process.cwd(), 'src', 'astrology', 'swissephAdapter.js'),
+    path.resolve(__dirname, 'src', 'astrology', 'swissephAdapter.js'),
+    '/src/astrology/swissephAdapter.js'
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return require(candidate);
+    }
+  }
+
+  const searched = findFile(process.cwd(), 'swissephAdapter.js');
+  if (searched) {
+    return require(searched);
+  }
+
+  throw new Error('Sweph adapter not found. Checked: ' + candidates.join(', ') + '. Searched from: ' + process.cwd());
+};
+
+const cliService = loadCliService();
+const swephAdapter = loadSwephAdapter();
+
+const rawCommand = process.argv.slice(2).join(' ').trim();
+
+if (!rawCommand) {
+  console.error('No command provided');
+  process.exit(1);
+}
+
+const command = rawCommand.startsWith('klio ') ? rawCommand.slice(5).trim() : rawCommand;
+
+process.env.KLIO_CAPTURE_ONLY = '1';
+process.env.KLIO_CONFIG_PATH = '/src/.astrocli/config.json';
+try {
+  const configText = fs.readFileSync(process.env.KLIO_CONFIG_PATH, 'utf8');
+  if (configText) {
+    process.env.KLIO_CONFIG_JSON = configText;
+  }
+} catch (error) {
+  // Config file may not exist yet.
+}
+
+swephAdapter.initialize().then(() => cliService.executeCommand(command)).then((result) => {
+  if (!result || !result.success) {
+    const message = result && result.output ? result.output : 'Command failed in WebContainer';
+    console.error(message);
+    process.exit(1);
+  }
+
+  if (result.output) {
+    const output = result.output.endsWith('\\n') ? result.output : result.output + '\\n';
+    process.stdout.write(output);
+  }
+}).catch((error) => {
+  const message = error && error.stack ? error.stack : (error && error.message ? error.message : String(error));
+  console.error(message);
+  process.exit(1);
+});
+`;
+  }
+}
+
+// Singleton instance
+const webcontainerSetup = new WebContainerSetup();
+
+module.exports = webcontainerSetup;

package/src/health/fileAnalysis.js

@@ -1,6 +1,6 @@
 const { getAstrologicalData, calculateHouses, getPlanetHouse } = require('../astrology/astrologyService');
 const { readFilesInFolder, getFileCreationDate, parseDateToComponents } = require('../utils/fileUtils');
-const swisseph = require('swisseph');
+const swisseph = require('../astrology/swissephAdapter');
 const path = require('path');
 
 // Function to analyze house distribution for a planet in a folder
@@ -150,4 +150,4 @@ async function filterFilesByHouse(planetName, folderPath, targetHouse, houseSyst
 module.exports = {
   analyzeHouseDistribution,
   filterFilesByHouse
-};
+};

package/src/gui/commandLogger.js

@@ -1,67 +0,0 @@
-const commandDatabase = require('./database');
-
-class CommandLogger {
-  constructor() {
-    this.isInitialized = false;
-  }
-
-  async initialize() {
-    try {
-      await commandDatabase.initialize();
-      this.isInitialized = true;
-    } catch (err) {
-      console.error('Failed to initialize command logger:', err);
-      this.isInitialized = false;
-    }
-  }
-
-  async logCommand(command, arguments = '', category = 'general', tags = '') {
-    if (!this.isInitialized) {
-      await this.initialize();
-    }
-
-    if (!this.isInitialized) {
-      return false;
-    }
-
-    try {
-      // Capture the command result by temporarily overriding console.log
-      const originalLog = console.log;
-      let capturedOutput = '';
-
-      console.log = (...args) => {
-        capturedOutput += args.join(' ') + '\n';
-        originalLog(...args);
-      };
-
-      // Execute the command (this would be called from CLI)
-      // For now, we'll just save the command structure
-      
-      const commandId = await commandDatabase.saveCommand(
-        command,
-        arguments,
-        '', // Result will be captured later
-        tags,
-        category
-      );
-
-      // Restore original console.log
-      console.log = originalLog;
-
-      return commandId;
-    } catch (err) {
-      console.error('Error logging command:', err);
-      return false;
-    }
-  }
-
-  async close() {
-    try {
-      await commandDatabase.close();
-    } catch (err) {
-      console.error('Error closing command logger:', err);
-    }
-  }
-}
-
-module.exports = new CommandLogger();

package/src/gui/database.js

@@ -1,135 +0,0 @@
-const sqlite3 = require('sqlite3').verbose();
-const path = require('path');
-const fs = require('fs');
-
-class CommandDatabase {
-  constructor() {
-    this.dbPath = path.join(__dirname, '..', '..', 'commands.db');
-    this.db = null;
-  }
-
-  async initialize() {
-    // Create directory if it doesn't exist
-    const dbDir = path.dirname(this.dbPath);
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true });
-    }
-
-    this.db = new sqlite3.Database(this.dbPath);
-
-    return new Promise((resolve, reject) => {
-      this.db.serialize(() => {
-        this.db.run(`
-          CREATE TABLE IF NOT EXISTS commands (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-            command TEXT NOT NULL,
-            arguments TEXT,
-            result TEXT,
-            tags TEXT,
-            category TEXT
-          )
-        `);
-
-        // Create indexes for better search performance
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_command ON commands(command)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_timestamp ON commands(timestamp)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_tags ON commands(tags)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_category ON commands(category)');
-      });
-
-      resolve();
-    });
-  }
-
-  async saveCommand(command, args = '', result = '', tags = '', category = '') {
-    return new Promise((resolve, reject) => {
-      const stmt = this.db.prepare(
-        'INSERT INTO commands (command, arguments, result, tags, category) VALUES (?, ?, ?, ?, ?)'
-      );
-      stmt.run([command, args, result, tags, category], function(err) {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(this.lastID);
-        }
-      });
-      stmt.finalize();
-    });
-  }
-
-  async getAllCommands() {
-    return new Promise((resolve, reject) => {
-      this.db.all('SELECT * FROM commands ORDER BY timestamp DESC', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(rows);
-        }
-      });
-    });
-  }
-
-  async searchCommands(query) {
-    return new Promise((resolve, reject) => {
-      const searchQuery = `%${query}%`;
-      this.db.all(`
-        SELECT * FROM commands 
-        WHERE command LIKE ? 
-        OR arguments LIKE ? 
-        OR result LIKE ? 
-        OR tags LIKE ? 
-        OR category LIKE ?
-        ORDER BY timestamp DESC
-      `, [searchQuery, searchQuery, searchQuery, searchQuery, searchQuery], (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(rows);
-        }
-      });
-    });
-  }
-
-  async getCommandById(id) {
-    return new Promise((resolve, reject) => {
-      this.db.get('SELECT * FROM commands WHERE id = ?', [id], (err, row) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(row);
-        }
-      });
-    });
-  }
-
-  async getCommandsByCategory(category) {
-    return new Promise((resolve, reject) => {
-      this.db.all('SELECT * FROM commands WHERE category = ? ORDER BY timestamp DESC', [category], (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(rows);
-        }
-      });
-    });
-  }
-
-  async close() {
-    return new Promise((resolve, reject) => {
-      if (this.db) {
-        this.db.close((err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-}
-
-module.exports = new CommandDatabase();