@fenwave/agent 1.1.0

package/auth.js

@@ -0,0 +1,276 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import axios from 'axios';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const AGENT_ROOT_DIR = path.join(
+  os.homedir(),
+  process.env.AGENT_ROOT_DIR || '.fenwave'
+);
+const SESSION_DIR = process.env.SESSION_DIR || 'session';
+const SESSION_FILE = process.env.SESSION_FILE || 'config.json';
+const CONFIG_FILE = path.join(AGENT_ROOT_DIR, SESSION_DIR, SESSION_FILE);
+
+/**
+ * Ensures the configuration directory exists
+ */
+function ensureConfigDirectory() {
+  const sessionDir = path.dirname(CONFIG_FILE);
+  if (!fs.existsSync(sessionDir)) {
+    fs.mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Saves session data to local config file
+ * @param {string} token - Session token
+ * @param {string} expiresAt - Expiration timestamp
+ * @param {string} userEntityRef - User entity reference
+ * @param {string} backendUrl - Optional backend URL to save
+ */
+function saveSession(token, expiresAt, userEntityRef, backendUrl = null) {
+  ensureConfigDirectory();
+  const config = {
+    token,
+    expiresAt,
+    userEntityRef,
+  };
+
+  // Preserve existing backend URL or save new one
+  if (backendUrl) {
+    config.backendUrl = backendUrl;
+  } else {
+    const existingConfig = loadSession();
+    if (existingConfig && existingConfig.backendUrl) {
+      config.backendUrl = existingConfig.backendUrl;
+    }
+  }
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Loads session data from local config file
+ * @returns {Object|null} Session data or null if not found
+ */
+function loadSession() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    return config;
+  } catch (error) {
+    console.error(chalk.red('❌ Error loading session config:'), error.message);
+    return null;
+  }
+}
+
+/**
+ * Checks if a session is still valid (not expired)
+ * @param {Object} session - Session data
+ * @returns {boolean} - True if session is valid
+ */
+function isSessionValid(session) {
+  if (!session || !session.token || !session.expiresAt) {
+    return false;
+  }
+  const now = new Date();
+  const expiresAt = new Date(session.expiresAt);
+  return now < expiresAt;
+}
+
+/**
+ * Handles session expiry by clearing session and exiting process
+ * @param {string} message - Optional message to display
+ * @param {Object} server - Optional WebSocket server to close
+ * @param {Object} wss - Optional WebSocket server instance to close
+ */
+function handleSessionExpiry(
+  message = 'Session has expired!',
+  server = null,
+  wss = null
+) {
+  console.log(chalk.red(`❌ ${message}`));
+  console.log(chalk.red('🔒 Fenwave Agent shutting down gracefully...'));
+
+  // Close WebSocket connections and server if provided
+  if (wss) {
+    wss.clients.forEach((client) => {
+      client.send(
+        JSON.stringify({
+          type: 'session_expired',
+          message: 'Session has expired. Please re-authenticate.',
+        })
+      );
+      client.close();
+    });
+    wss.close();
+  }
+
+  if (server) {
+    server.close();
+  }
+
+  clearSession();
+  console.log(chalk.yellow("💡 Please run 'fenwave login' to authenticate again."));
+  process.exit(1);
+}
+
+/**
+ * Creates a new session with the Backstage backend
+ * @param {string} jwt - Token for authentication
+ * @param {string} backendUrl - Backend URL
+ * @returns {Object} Session data with token, userEntityRef and expiresAt
+ */
+async function createSession(jwt, backendUrl) {
+  try {
+    const response = await axios.post(
+      `${backendUrl}/api/agent-cli/create-session`,
+      {},
+      {
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+    console.log(chalk.green('✅ Session created successfully!'));
+    const { token, expiresAt } = response.data;
+    return { token, expiresAt };
+  } catch (error) {
+    console.error(
+      chalk.red('❌ Failed to create session: '),
+      error.response?.data || error.message
+    );
+    throw error;
+  }
+}
+
+/**
+ * Clears the stored session
+ */
+function clearSession() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Sets up a file watcher to monitor session file changes
+ * @param {Function} onSessionExpired - Callback function to handle session expiry
+ * @param {Object} server - WebSocket server instance
+ * @param {Object} wss - WebSocket server instance
+ * @returns {Object} File watcher instance
+ */
+function setupSessionWatcher(onSessionExpired, server = null, wss = null) {
+  let watcher = null;
+  let expiryTimer = null;
+
+  // Set up timer for natural expiry
+  const session = loadSession();
+  if (session && session.expiresAt) {
+    const expiryTime = new Date(session.expiresAt).getTime();
+    const currentTime = Date.now();
+    const timeUntilExpiry = expiryTime - currentTime;
+
+    if (timeUntilExpiry > 0) {
+      expiryTimer = setTimeout(() => {
+        clearSession();
+        onSessionExpired('Session expired !', server, wss);
+      }, timeUntilExpiry);
+    }
+  }
+
+  try {
+    // Watch the config file for changes/deletion
+    watcher = fs.watch(CONFIG_FILE, (eventType, filename) => {
+      // Clear the natural expiry timer since file changed
+      if (expiryTimer) {
+        clearTimeout(expiryTimer);
+        expiryTimer = null;
+      }
+
+      // Check if file was deleted or renamed (session revoked by logout)
+      if (eventType === 'rename' || !fs.existsSync(CONFIG_FILE)) {
+        if (watcher) {
+          watcher.close();
+        }
+        onSessionExpired('Session revoked !', server, wss);
+        return;
+      }
+    });
+    return {
+      close: () => {
+        if (watcher) watcher.close();
+        if (expiryTimer) clearTimeout(expiryTimer);
+      },
+    };
+  } catch (error) {
+    // Clear expiry timer if file watcher fails
+    if (expiryTimer) {
+      clearTimeout(expiryTimer);
+      expiryTimer = null;
+    }
+
+    // Fallback to periodic checking if file watching fails
+    const intervalId = setInterval(() => {
+      if (!fs.existsSync(CONFIG_FILE)) {
+        clearInterval(intervalId);
+        onSessionExpired('Session revoked !', server, wss);
+        return;
+      }
+
+      const currentSession = loadSession();
+      if (!currentSession || !isSessionValid(currentSession)) {
+        clearInterval(intervalId);
+        onSessionExpired('Session expired !', server, wss);
+      }
+    }, 30 * 1000); // Check every 30 seconds as fallback
+
+    return { close: () => clearInterval(intervalId) };
+  }
+}
+
+/**
+ * Loads backend URL from agent config or environment variable
+ * NOTE: This function loads synchronously from the config file
+ * @returns {string|undefined} Backend URL
+ */
+function loadBackendUrl() {
+  // Load directly from config file to avoid circular dependencies
+  const configPath = path.join(os.homedir(), '.fenwave', 'config', 'agent.json');
+
+  // Try to load from config file
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (config.backendUrl) {
+        return config.backendUrl;
+      }
+    } catch (error) {
+      // Fall through to env variable
+    }
+  }
+
+  // Fall back to environment variable
+  return process.env.BACKEND_URL || 'http://localhost:7007';
+}
+
+export {
+  saveSession,
+  loadSession,
+  isSessionValid,
+  handleSessionExpiry,
+  createSession,
+  clearSession,
+  setupSessionWatcher,
+  loadBackendUrl,
+};