@fenwave/agent 1.1.0

package/store/configStore.js

@@ -0,0 +1,174 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const CONFIG_DIR = path.join(FENWAVE_DIR, 'config');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'agent.json');
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+  // Backstage URLs
+  backendUrl: 'http://localhost:7007',
+  frontendUrl: 'http://localhost:3000',
+  appBuilderUrl: null, // Will default to backendUrl if not set
+
+  // Container Configuration
+  containerName: 'fenwave-devapp',
+  containerPort: 3003,
+  wsPort: 3001,
+
+  // Directory Configuration
+  agentRootDir: '.fenwave',
+  registriesDir: 'registries',
+  containerDataDir: '/data',
+
+  // AWS/ECR Configuration
+  awsRegion: 'eu-west-1',
+  awsAccountId: null, // Set during registration from Backstage
+  dockerImage: null, // Will be computed if awsAccountId is set
+
+  // Other Settings
+  authTimeoutMs: 60000,
+};
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Load configuration from disk
+ * @returns {Object} Configuration object with defaults applied
+ */
+export function loadConfig() {
+  let config = { ...DEFAULT_CONFIG };
+
+  // Load from file if exists
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const fileConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      config = { ...config, ...fileConfig };
+    } catch (error) {
+      console.error('Failed to load agent config:', error.message);
+    }
+  }
+
+  // Apply computed defaults
+  if (!config.appBuilderUrl) {
+    config.appBuilderUrl = config.backendUrl;
+  }
+
+  // Only compute dockerImage if awsAccountId is configured
+  if (!config.dockerImage && config.awsAccountId && config.awsRegion) {
+    config.dockerImage = `${config.awsAccountId}.dkr.ecr.${config.awsRegion}.amazonaws.com/fenwave/devapp:latest`;
+  }
+
+  // Fall back to environment variables if config values are not set
+  config.backendUrl = config.backendUrl || process.env.BACKEND_URL || DEFAULT_CONFIG.backendUrl;
+  config.frontendUrl = config.frontendUrl || process.env.FRONTEND_URL || DEFAULT_CONFIG.frontendUrl;
+  config.wsPort = config.wsPort || Number(process.env.WS_PORT) || DEFAULT_CONFIG.wsPort;
+  config.containerPort = config.containerPort || Number(process.env.CONTAINER_PORT) || DEFAULT_CONFIG.containerPort;
+
+  return config;
+}
+
+/**
+ * Save configuration to disk
+ * @param {Object} config - Configuration object to save
+ */
+export function saveConfig(config) {
+  ensureConfigDir();
+
+  const configToSave = {
+    ...config,
+    updatedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(configToSave, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Update specific configuration values
+ * @param {Object} updates - Configuration updates
+ */
+export function updateConfig(updates) {
+  const currentConfig = loadConfig();
+  const newConfig = { ...currentConfig, ...updates };
+  saveConfig(newConfig);
+  return newConfig;
+}
+
+/**
+ * Get a specific configuration value
+ * @param {string} key - Configuration key
+ * @param {any} defaultValue - Default value if key not found
+ * @returns {any} Configuration value
+ */
+export function getConfig(key, defaultValue = null) {
+  const config = loadConfig();
+  return config[key] !== undefined ? config[key] : defaultValue;
+}
+
+/**
+ * Check if configuration file exists
+ * @returns {boolean} True if config file exists
+ */
+export function configExists() {
+  return fs.existsSync(CONFIG_FILE);
+}
+
+/**
+ * Clear configuration file
+ */
+export function clearConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}
+
+/**
+ * Get configuration file path
+ * @returns {string} Path to config file
+ */
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * Initialize configuration with values from init wizard
+ * @param {Object} initConfig - Configuration from init wizard
+ */
+export function initializeConfig(initConfig) {
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...initConfig,
+    createdAt: new Date().toISOString(),
+  };
+
+  saveConfig(config);
+  return config;
+}
+
+export default {
+  loadConfig,
+  saveConfig,
+  updateConfig,
+  getConfig,
+  configExists,
+  clearConfig,
+  getConfigPath,
+  initializeConfig,
+  DEFAULT_CONFIG,
+};

package/store/deviceCredentialStore.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { encrypt, decrypt } from '../utils/encryption.js';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const DEVICE_DIR = path.join(FENWAVE_DIR, 'device');
+const CREDENTIAL_FILE = path.join(DEVICE_DIR, 'credential.json');
+
+/**
+ * Ensure device directory exists
+ */
+function ensureDeviceDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(DEVICE_DIR)) {
+    fs.mkdirSync(DEVICE_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Save device credential to disk (encrypted)
+ *
+ * @param {Object} credentialData - Device credential data
+ * @param {string} credentialData.deviceId - Device ID
+ * @param {string} credentialData.deviceCredential - Device credential
+ * @param {string} credentialData.userEntityRef - User entity reference
+ * @param {string} credentialData.deviceName - Device name
+ * @param {string} credentialData.platform - Platform
+ * @param {string} credentialData.agentVersion - Agent version
+ */
+export function saveDeviceCredential(credentialData) {
+  ensureDeviceDir();
+
+  const data = {
+    deviceId: credentialData.deviceId,
+    deviceCredential: encrypt(credentialData.deviceCredential), // Encrypt credential
+    userEntityRef: credentialData.userEntityRef,
+    deviceName: credentialData.deviceName,
+    platform: credentialData.platform,
+    agentVersion: credentialData.agentVersion,
+    registeredAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(CREDENTIAL_FILE, JSON.stringify(data, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Load device credential from disk
+ *
+ * @returns {Object|null} Device credential data or null if not found
+ */
+export function loadDeviceCredential() {
+  if (!fs.existsSync(CREDENTIAL_FILE)) {
+    return null;
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIAL_FILE, 'utf8'));
+
+    // Decrypt the credential
+    const decryptedCredential = decrypt(data.deviceCredential);
+
+    return {
+      deviceId: data.deviceId,
+      deviceCredential: decryptedCredential,
+      userEntityRef: data.userEntityRef,
+      deviceName: data.deviceName,
+      platform: data.platform,
+      agentVersion: data.agentVersion,
+      registeredAt: data.registeredAt,
+    };
+  } catch (error) {
+    console.error('Failed to load device credential:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Check if device is registered
+ *
+ * @returns {boolean} True if device credential exists
+ */
+export function isDeviceRegistered() {
+  return fs.existsSync(CREDENTIAL_FILE);
+}
+
+/**
+ * Clear device credential (delete file)
+ */
+export function clearDeviceCredential() {
+  if (fs.existsSync(CREDENTIAL_FILE)) {
+    fs.unlinkSync(CREDENTIAL_FILE);
+  }
+}
+
+/**
+ * Get device credential file path
+ *
+ * @returns {string} Path to credential file
+ */
+export function getCredentialFilePath() {
+  return CREDENTIAL_FILE;
+}

package/store/npmTokenStore.js

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const NPM_DIR = path.join(FENWAVE_DIR, 'npm');
+const NPM_TOKEN_FILE = path.join(NPM_DIR, 'token');
+
+/**
+ * Ensure NPM directory exists
+ */
+function ensureNpmDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(NPM_DIR)) {
+    fs.mkdirSync(NPM_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Save NPM token to disk
+ *
+ * @param {string} token - NPM token
+ */
+export function saveNpmToken(token) {
+  ensureNpmDir();
+  fs.writeFileSync(NPM_TOKEN_FILE, token, { mode: 0o600 });
+}
+
+/**
+ * Load NPM token from disk
+ *
+ * @returns {string|null} NPM token or null if not found
+ */
+export function loadNpmToken() {
+  if (!fs.existsSync(NPM_TOKEN_FILE)) {
+    return null;
+  }
+
+  try {
+    return fs.readFileSync(NPM_TOKEN_FILE, 'utf8').trim();
+  } catch (error) {
+    console.error('Failed to load NPM token:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Check if NPM token exists
+ *
+ * @returns {boolean} True if NPM token is configured
+ */
+export function hasNpmToken() {
+  return fs.existsSync(NPM_TOKEN_FILE);
+}
+
+/**
+ * Clear NPM token (delete file)
+ */
+export function clearNpmToken() {
+  if (fs.existsSync(NPM_TOKEN_FILE)) {
+    fs.unlinkSync(NPM_TOKEN_FILE);
+  }
+}

package/store/registryStore.js

@@ -0,0 +1,329 @@
+import os from "os";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import dotenv from "dotenv";
+dotenv.config();
+
+const fsPromises = fs.promises;
+
+const AGENT_ROOT_DIR = process.env.AGENT_ROOT_DIR || ".fenwave";
+const REGISTRIES_DIR = process.env.REGISTRIES_DIR || "registries";
+const REGISTRIES_FILE = process.env.REGISTRIES_FILE || "credentials.json";
+const REGISTRY_FILE = path.join(
+  os.homedir(),
+  AGENT_ROOT_DIR,
+  REGISTRIES_DIR,
+  REGISTRIES_FILE
+);
+
+const SCHEMA_VERSION = 1;
+
+/**
+ * Registry Store for managing registry credentials
+ */
+class RegistryStore {
+  constructor() {
+    this.registries = new Map();
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the store - load registries
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Ensure directory exists
+      await this.ensureDirectory();
+
+      // Load existing registries
+      await this.loadRegistries();
+
+      this.initialized = true;
+    } catch (error) {
+      console.error(
+        chalk.red("❌ Failed to initialize registry store:", error.message)
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Ensure the .fenwave/registries directory exists
+   */
+  async ensureDirectory() {
+    const dir = path.dirname(REGISTRY_FILE);
+    try {
+      await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Load registries from file
+   */
+  async loadRegistries() {
+    try {
+      const data = await fsPromises.readFile(REGISTRY_FILE, "utf8");
+      const parsed = JSON.parse(data);
+
+      if (parsed.version !== SCHEMA_VERSION) {
+        console.warn(
+          `⚠️ Registry file version mismatch. Expected ${SCHEMA_VERSION}, got ${parsed.version}`
+        );
+      }
+
+      // Load registries with plain text credentials
+      let hasActiveRegistry = false;
+
+      for (const registry of parsed.registries || []) {
+        try {
+          // Ensure active field exists (for backward compatibility)
+          if (registry.active === undefined) {
+            registry.active = false;
+          }
+
+          if (registry.active) {
+            hasActiveRegistry = true;
+          }
+
+          // Store registry with credentials directly
+          this.registries.set(registry.id, registry);
+        } catch (error) {
+          console.error(
+            chalk.red(`❌ Failed to load registry ${registry.id}:`),
+            error.message
+          );
+          // Skip this registry but continue with others
+        }
+      }
+
+      // If no registry is marked as active, make the first one active
+      if (!hasActiveRegistry && this.registries.size > 0) {
+        const firstRegistry = this.registries.values().next().value;
+        if (firstRegistry) {
+          firstRegistry.active = true;
+          firstRegistry.updatedAt = new Date().toISOString();
+          // Save the updated registries with the active flag
+          await this.saveRegistries();
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        // File doesn't exist yet, start with empty registries
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Save registries to file with plain text credentials
+   */
+  async saveRegistries() {
+    try {
+      const registriesToSave = [];
+
+      for (const [id, registry] of this.registries.entries()) {
+        // Save registry with credentials directly
+        registriesToSave.push(registry);
+      }
+
+      const data = {
+        version: SCHEMA_VERSION,
+        registries: registriesToSave,
+        updatedAt: new Date().toISOString(),
+      };
+
+      // Write atomically
+      const tempFile = REGISTRY_FILE + ".tmp";
+      await fsPromises.writeFile(tempFile, JSON.stringify(data, null, 2), {
+        mode: 0o600,
+      });
+      await fsPromises.rename(tempFile, REGISTRY_FILE);
+    } catch (error) {
+      console.error(chalk.red("❌ Failed to save registries:", error.message));
+      throw error;
+    }
+  }
+
+  /**
+   * Add or update a registry
+   */
+  async upsertRegistry(registryData) {
+    await this.initialize();
+
+    const { id, credentials, ...metadata } = registryData;
+
+    const registry = {
+      id,
+      ...metadata,
+      credentials,
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (!this.registries.has(id)) {
+      registry.createdAt = registry.updatedAt;
+      // If this is the first registry, make it active by default
+      if (this.registries.size === 0) {
+        registry.active = true;
+      } else {
+        registry.active = false;
+      }
+    }
+
+    this.registries.set(id, registry);
+    await this.saveRegistries();
+
+    return registry;
+  }
+
+  /**
+   * Get all registries (returns metadata only, no credentials)
+   */
+  async getAllRegistries() {
+    await this.initialize();
+
+    const result = [];
+    for (const [id, registry] of this.registries.entries()) {
+      const { credentials, ...safeRegistry } = registry;
+
+      // Add type-specific safe metadata
+      const metadata = { ...safeRegistry };
+      if (registry.type === "ecr" && credentials) {
+        metadata.accessKeyId = credentials.accessKeyId;
+        metadata.region = registry.region;
+      } else if (registry.type === "gcr" && credentials?.serviceAccountJson) {
+        try {
+          const serviceAccount = JSON.parse(credentials.serviceAccountJson);
+          metadata.projectId = serviceAccount.project_id;
+        } catch (error) {
+          console.error("Error parsing service account JSON:", error);
+        }
+      } else if (credentials?.username) {
+        metadata.username = credentials.username;
+      }
+
+      // Ensure active field is included (default to false if not set)
+      metadata.active = registry.active || false;
+
+      result.push(metadata);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get registry with credentials (for agent operations)
+   */
+  async getRegistryWithCredentials(id) {
+    await this.initialize();
+    return this.registries.get(id);
+  }
+
+  /**
+   * Remove a registry
+   */
+  async removeRegistry(id) {
+    await this.initialize();
+
+    const registryToRemove = this.registries.get(id);
+    const deleted = this.registries.delete(id);
+
+    if (deleted) {
+      // If we removed the active registry, set another one as active
+      if (
+        registryToRemove &&
+        registryToRemove.active &&
+        this.registries.size > 0
+      ) {
+        // Set the first remaining registry as active
+        const firstRegistry = this.registries.values().next().value;
+        if (firstRegistry) {
+          firstRegistry.active = true;
+          firstRegistry.updatedAt = new Date().toISOString();
+        }
+      }
+
+      await this.saveRegistries();
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Get registry count
+   */
+  async getRegistryCount() {
+    await this.initialize();
+    return this.registries.size;
+  }
+
+  /**
+   * Clear all registries (for logout/cleanup)
+   */
+  async clearAll() {
+    await this.initialize();
+    this.registries.clear();
+    await this.saveRegistries();
+    console.log("🧹 All registries cleared");
+  }
+
+  /**
+   * Set active registry
+   */
+  async setActiveRegistry(id) {
+    await this.initialize();
+
+    // First, set all registries to inactive
+    for (const [registryId, registry] of this.registries.entries()) {
+      registry.active = false;
+    }
+
+    // Then set the specified registry as active
+    if (id && this.registries.has(id)) {
+      const registry = this.registries.get(id);
+      registry.active = true;
+      registry.updatedAt = new Date().toISOString();
+      await this.saveRegistries();
+      return registry;
+    }
+
+    // If no valid id provided, save anyway to clear all active states
+    await this.saveRegistries();
+    return null;
+  }
+
+  /**
+   * Get active registry
+   */
+  async getActiveRegistry() {
+    await this.initialize();
+
+    for (const [id, registry] of this.registries.entries()) {
+      if (registry.active) {
+        return registry;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get active registry ID
+   */
+  async getActiveRegistryId() {
+    const activeRegistry = await this.getActiveRegistry();
+    return activeRegistry ? activeRegistry.id : null;
+  }
+}
+
+// Singleton instance
+const registryStore = new RegistryStore();
+
+export default registryStore;