@fenwave/agent 1.1.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@fenwave/agent",
+  "version": "1.1.0",
+  "description": "Fenwave Docker Agent and CLI",
+  "keywords": [
+    "fenwave",
+    "fenleap",
+    "fenwave-idp"
+  ],
+  "homepage": "https://github.com/Fenleap/Fenwave-plugins#readme",
+  "bugs": {
+    "url": "https://github.com/Fenleap/Fenwave-plugins/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Fenleap/Fenwave-plugins.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Fenleap",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "fenwave": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js server",
+    "agent": "node index.js"
+  },
+  "dependencies": {
+    "@aws-sdk/client-ecr": "^3.879.0",
+    "@aws-sdk/client-sts": "^3.879.0",
+    "axios": "^1.11.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.0.0",
+    "dockerode": "^4.0.0",
+    "dotenv": "^16.0.3",
+    "google-auth-library": "^9.0.0",
+    "inquirer": "^8.2.5",
+    "js-yaml": "^4.1.0",
+    "open": "^11.0.0",
+    "ora": "^5.4.1",
+    "uuid": "^9.0.1",
+    "ws": "^8.15.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/setup/setupWizard.js

@@ -0,0 +1,499 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+import axios from "axios";
+import {
+  checkPrerequisites,
+  displayPrerequisites,
+  getMissingPrerequisites,
+} from "../utils/prerequisites.js";
+import {
+  promptRegistrationToken,
+  promptConfirmation,
+  displayProgress,
+  displaySuccess,
+  displayError,
+  displayWarning,
+  displayInfo,
+  displayHeader,
+  displayStep,
+  displayKeyValue,
+} from "../utils/prompts.js";
+import {
+  handleError,
+  createError,
+  ErrorCode,
+  isUserCancellation,
+} from "../utils/errorHandler.js";
+import { getDeviceMetadata, displayDeviceInfo } from "../utils/deviceInfo.js";
+import {
+  saveDeviceCredential,
+  isDeviceRegistered,
+} from "../store/deviceCredentialStore.js";
+import { saveNpmToken } from "../store/npmTokenStore.js";
+import {
+  saveSetupProgress,
+  clearSetupState,
+  SetupStep,
+  isSetupInProgress,
+} from "../store/setupState.js";
+import { authenticateDockerWithECR } from "../utils/ecrAuth.js";
+import { initializeConfig } from "../store/configStore.js";
+
+const TOTAL_STEPS = 7;
+
+/**
+ * Setup Wizard Orchestrator
+ * Guides user through complete agent setup
+ */
+export class SetupWizard {
+  constructor(options = {}) {
+    this.backendUrl = options.backendUrl || "http://localhost:7007";
+    this.frontendUrl = options.frontendUrl || "http://localhost:3000";
+    this.awsRegion = options.awsRegion || "eu-west-1";
+    this.awsAccountId = options.awsAccountId || null; // Will be set from Backstage during registration
+    this.skipPrerequisites = options.skipPrerequisites || false;
+    this.registrationToken = options.token || null;
+  }
+
+  /**
+   * Run the complete setup wizard
+   */
+  async run() {
+    try {
+      // Welcome message
+      this.displayWelcome();
+
+      // Initialize and save agent configuration
+      const agentConfig = {
+        backendUrl: this.backendUrl,
+        frontendUrl: this.frontendUrl,
+        awsRegion: this.awsRegion,
+        awsAccountId: this.awsAccountId,
+      };
+
+      initializeConfig(agentConfig);
+
+      displayInfo("Agent configuration initialized:");
+      displayKeyValue("Backend URL", this.backendUrl);
+      displayKeyValue("Frontend URL", this.frontendUrl);
+      displayKeyValue("AWS Region", this.awsRegion);
+      if (this.awsAccountId) {
+        displayKeyValue("AWS Account ID", this.awsAccountId);
+      }
+      console.log("");
+
+      // Check if already registered
+      if (isDeviceRegistered()) {
+        displayWarning("Device is already registered!");
+        const shouldContinue = await promptConfirmation(
+          "Do you want to re-register (this will replace existing credentials)?",
+          false
+        );
+
+        if (!shouldContinue) {
+          displayInfo(
+            'Setup cancelled. Use "fenwave status" to view current registration.'
+          );
+          return;
+        }
+      }
+
+      // Check for interrupted setup
+      if (isSetupInProgress()) {
+        const resume = await promptConfirmation(
+          "Found interrupted setup. Do you want to resume?",
+          true
+        );
+
+        if (!resume) {
+          clearSetupState();
+        }
+      }
+
+      // Step 1: Prerequisites Check
+      await this.checkPrerequisitesStep();
+
+      // Step 2: Device Registration
+      const registrationData = await this.registrationStep();
+
+      // Step 3: Docker Registry Configuration
+      await this.dockerRegistryStep(registrationData);
+
+      // Step 4: Pull DevApp Image
+      await this.pullImageStep(registrationData);
+
+      // Step 5: NPM Configuration
+      await this.npmConfigStep(registrationData);
+
+      // Step 6: Start Agent (optional)
+      await this.startAgentStep();
+
+      // Step 7: Complete
+      this.displayComplete(registrationData);
+
+      // Clear setup state
+      clearSetupState();
+    } catch (error) {
+      if (isUserCancellation(error)) {
+        displayWarning("\nSetup cancelled by user.");
+        displayInfo('Run "fenwave init" again to resume setup.\n');
+      } else {
+        handleError(error, "Setup Wizard");
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Display welcome message
+   */
+  displayWelcome() {
+    displayHeader("Fenwave Dev Agent Setup Wizard");
+    console.log(
+      chalk.gray(
+        "  This wizard will guide you through setting up the Fenwave Dev Agent.\n"
+      )
+    );
+    console.log(
+      chalk.gray("  You can interrupt the setup anytime and resume later.\n")
+    );
+  }
+
+  /**
+   * Step 1: Check prerequisites
+   */
+  async checkPrerequisitesStep() {
+    displayStep(1, TOTAL_STEPS, "Checking Prerequisites");
+
+    if (this.skipPrerequisites) {
+      displayInfo("Skipping prerequisites check (--skip-prerequisites flag)");
+      return;
+    }
+
+    const checkResults = await checkPrerequisites({
+      backendUrl: this.backendUrl,
+    });
+    const allPassed = displayPrerequisites(checkResults);
+
+    if (!allPassed) {
+      const missing = getMissingPrerequisites(checkResults);
+
+      console.log(chalk.yellow("\n⚠️  Missing prerequisites:\n"));
+      missing.forEach((item) => {
+        console.log(chalk.red(`  ❌ ${item.name}: ${item.reason}`));
+        console.log(chalk.gray(`     Action: ${item.action}\n`));
+      });
+
+      const shouldContinue = await promptConfirmation(
+        "Some prerequisites are missing. Continue anyway?",
+        false
+      );
+
+      if (!shouldContinue) {
+        throw createError(
+          ErrorCode.OPERATION_CANCELLED,
+          "Prerequisites check failed"
+        );
+      }
+    }
+
+    saveSetupProgress(SetupStep.PREREQUISITES, { allPassed });
+  }
+
+  /**
+   * Step 2: Device Registration
+   */
+  async registrationStep() {
+    displayStep(2, TOTAL_STEPS, "Device Registration");
+
+    // Get registration token
+    if (!this.registrationToken) {
+      this.registrationToken = await promptRegistrationToken(this.backendUrl);
+    }
+
+    // Collect device information
+    const deviceMetadata = await getDeviceMetadata();
+    displayInfo("Collected device information:");
+    displayDeviceInfo(deviceMetadata);
+
+    // Register device with backend
+    const registrationData = await displayProgress(
+      "Registering device with Backstage...",
+      this.registerDevice(deviceMetadata)
+    );
+
+    // Save device credentials
+    saveDeviceCredential({
+      deviceId: registrationData.deviceId,
+      deviceCredential: registrationData.deviceCredential,
+      userEntityRef: registrationData.userEntityRef,
+      deviceName: deviceMetadata.deviceName,
+      platform: deviceMetadata.platform,
+      agentVersion: deviceMetadata.agentVersion,
+    });
+
+    displaySuccess(`Device registered: ${registrationData.deviceId}`);
+    console.log(chalk.gray(`   User: ${registrationData.userEntityRef}\n`));
+
+    saveSetupProgress(SetupStep.REGISTRATION, {
+      deviceId: registrationData.deviceId,
+      deviceName: deviceMetadata.deviceName,
+    });
+
+    return registrationData;
+  }
+
+  /**
+   * Register device with backend
+   */
+  async registerDevice(deviceMetadata) {
+    try {
+      const response = await axios.post(
+        `${this.backendUrl}/api/agent-cli/register`,
+        {
+          installToken: this.registrationToken,
+          deviceInfo: {
+            deviceName: deviceMetadata.deviceName,
+            platform: deviceMetadata.platform,
+            osVersion: deviceMetadata.osVersion,
+            agentVersion: deviceMetadata.agentVersion,
+            metadata: deviceMetadata.metadata,
+          },
+        },
+        { timeout: 10000 }
+      );
+
+      return {
+        deviceId: response.data.deviceId,
+        deviceCredential: response.data.deviceCredential,
+        npmToken: response.data.npmToken,
+        registryConfig: response.data.registryConfig,
+        userEntityRef: response.data.userEntityRef || "unknown",
+      };
+    } catch (error) {
+      if (error.response?.status === 401) {
+        throw createError(
+          ErrorCode.INVALID_TOKEN,
+          "Invalid or expired registration token"
+        );
+      }
+      if (error.response?.status === 429) {
+        throw createError(
+          ErrorCode.RATE_LIMIT_EXCEEDED,
+          "Too many registration attempts"
+        );
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Step 3: Docker Registry Configuration
+   */
+  async dockerRegistryStep(registrationData) {
+    displayStep(3, TOTAL_STEPS, "Docker Registry Configuration");
+
+    const shouldConfigure = await promptConfirmation(
+      "Configure AWS ECR for Fenwave images?",
+      true
+    );
+
+    if (!shouldConfigure) {
+      displayInfo("Skipping Docker registry configuration");
+      saveSetupProgress(SetupStep.DOCKER_REGISTRY, { skipped: true });
+      return;
+    }
+
+    const { awsRegion, awsAccountId } = registrationData.registryConfig;
+
+    displayInfo(`Authenticating with AWS ECR (${awsRegion})...`);
+    displayInfo(
+      "🔐 Using Backstage-controlled credential flow (temporary credentials)"
+    );
+
+    try {
+      // Use Backstage-controlled credential flow
+      const authResult = await authenticateDockerWithECR(this.backendUrl);
+
+      displaySuccess("AWS ECR authenticated successfully");
+      displayInfo(`✅ Credentials expire at: ${authResult.expiration}`);
+      displayInfo(`📦 Registry: ${authResult.registryUri}`);
+
+      saveSetupProgress(SetupStep.DOCKER_REGISTRY, {
+        awsRegion: authResult.region,
+        awsAccountId: authResult.accountId,
+        registryUri: authResult.registryUri,
+        expiration: authResult.expiration,
+      });
+    } catch (error) {
+      displayError("Failed to authenticate with AWS ECR");
+      displayError(`Error: ${error.message}`);
+      displayWarning(
+        "Make sure your device is registered and Backstage is running"
+      );
+
+      const shouldContinue = await promptConfirmation(
+        "Continue without ECR authentication?",
+        true
+      );
+      if (!shouldContinue) {
+        throw createError(
+          ErrorCode.ECR_AUTH_FAILED,
+          "ECR authentication failed"
+        );
+      }
+
+      saveSetupProgress(SetupStep.DOCKER_REGISTRY, {
+        failed: true,
+        error: error.message,
+      });
+    }
+  }
+
+  /**
+   * Step 4: Pull Fenwave DevApp Image
+   */
+  async pullImageStep(registrationData) {
+    displayStep(4, TOTAL_STEPS, "Pull Fenwave DevApp Image");
+
+    const shouldPull = await promptConfirmation(
+      "Pull Fenwave DevApp Docker image?",
+      true
+    );
+
+    if (!shouldPull) {
+      displayInfo("Skipping image pull");
+      saveSetupProgress(SetupStep.PULL_IMAGE, { skipped: true });
+      return;
+    }
+
+    const { dockerImage } = registrationData.registryConfig;
+
+    try {
+      displayInfo(`Pulling image: ${dockerImage}`);
+      displayWarning("This may take a few minutes...");
+
+      await this.pullDockerImage(dockerImage);
+
+      displaySuccess("Docker image pulled successfully");
+      saveSetupProgress(SetupStep.PULL_IMAGE, { dockerImage });
+    } catch (error) {
+      displayError("Failed to pull Docker image");
+
+      const shouldContinue = await promptConfirmation(
+        "Continue without pulling image?",
+        true
+      );
+      if (!shouldContinue) {
+        throw createError(
+          ErrorCode.DOCKER_PULL_FAILED,
+          "Docker image pull failed"
+        );
+      }
+
+      saveSetupProgress(SetupStep.PULL_IMAGE, { failed: true });
+    }
+  }
+
+  /**
+   * Pull Docker image
+   */
+  async pullDockerImage(imageName) {
+    return new Promise((resolve, reject) => {
+      try {
+        execSync(`docker pull ${imageName}`, {
+          stdio: "inherit",
+        });
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Step 5: NPM Configuration
+   */
+  async npmConfigStep(registrationData) {
+    displayStep(5, TOTAL_STEPS, "NPM Configuration");
+
+    const { npmToken } = registrationData;
+
+    if (npmToken) {
+      saveNpmToken(npmToken);
+      displaySuccess("NPM token configured for future updates");
+      saveSetupProgress(SetupStep.NPM_CONFIG, { configured: true });
+    } else {
+      displayWarning("No NPM token provided by backend");
+      saveSetupProgress(SetupStep.NPM_CONFIG, { configured: false });
+    }
+  }
+
+  /**
+   * Step 6: Start Agent (optional)
+   */
+  async startAgentStep() {
+    displayStep(6, TOTAL_STEPS, "Start Agent Service");
+
+    const shouldStart = await promptConfirmation("Start the agent now?", true);
+
+    if (!shouldStart) {
+      displayInfo("You can start the agent later with: fenwave login");
+      saveSetupProgress(SetupStep.START_AGENT, { started: false });
+      return;
+    }
+
+    displayInfo("Starting agent requires authentication...");
+    displayInfo("Please run: fenwave login");
+
+    saveSetupProgress(SetupStep.START_AGENT, { started: false });
+  }
+
+  /**
+   * Display completion message
+   */
+  displayComplete(registrationData) {
+    displayStep(7, TOTAL_STEPS, "Setup Complete! 🎉");
+
+    console.log("");
+    displayHeader("Setup Summary");
+
+    displayKeyValue({
+      "Device ID": registrationData.deviceId,
+      "Device Name": registrationData.deviceName || "N/A",
+      Platform: registrationData.platform || "N/A",
+      User: registrationData.userEntityRef || "N/A",
+    });
+
+    console.log("");
+    console.log(chalk.green.bold("✅ Setup completed successfully!\n"));
+
+    console.log(chalk.bold("Next Steps:\n"));
+    console.log(chalk.gray("  1. Start the agent:"));
+    console.log(chalk.cyan("     $ fenwave login\n"));
+    console.log(chalk.gray("  2. Check agent status:"));
+    console.log(chalk.cyan("     $ fenwave status\n"));
+    console.log(chalk.gray("  3. View agent information:"));
+    console.log(chalk.cyan("     $ fenwave info\n"));
+
+    console.log(chalk.bold("Documentation:\n"));
+    console.log(
+      chalk.gray("  • View all commands: ") + chalk.cyan("fenwave --help")
+    );
+    console.log(
+      chalk.gray("  • Setup guide: ") + chalk.cyan("fenwave setup-guide")
+    );
+    console.log("");
+  }
+}
+
+/**
+ * Run setup wizard
+ *
+ * @param {Object} options - Wizard options
+ * @returns {Promise<void>}
+ */
+export async function runSetupWizard(options = {}) {
+  const wizard = new SetupWizard(options);
+  await wizard.run();
+}

package/store/agentSessionStore.js

@@ -0,0 +1,51 @@
+/**
+ * Agent Session Store
+ * Stores agent session information in memory
+ * This is a separate module to avoid circular dependencies
+ */
+
+// Store agent session info (will be set when server starts)
+let agentSessionInfo = {
+  agentId: null,
+  userEntityRef: null,
+  sessionExpiresAt: null,
+};
+
+/**
+ * Set agent session info
+ * @param {object} sessionInfo - Session information
+ */
+function setAgentSessionInfo(sessionInfo) {
+  agentSessionInfo.agentId = sessionInfo.agentId || null;
+  agentSessionInfo.userEntityRef = sessionInfo.userEntityRef || null;
+  agentSessionInfo.sessionExpiresAt = sessionInfo.sessionExpiresAt || null;
+}
+
+/**
+ * Get agent session info
+ * @returns {object} Agent session info
+ */
+function getAgentSessionInfo() {
+  return agentSessionInfo;
+}
+
+/**
+ * Clear agent session info
+ */
+function clearAgentSessionInfo() {
+  agentSessionInfo.agentId = null;
+  agentSessionInfo.userEntityRef = null;
+  agentSessionInfo.sessionExpiresAt = null;
+}
+
+export default {
+  setAgentSessionInfo,
+  getAgentSessionInfo,
+  clearAgentSessionInfo,
+};
+
+export {
+  setAgentSessionInfo,
+  getAgentSessionInfo,
+  clearAgentSessionInfo,
+};

package/store/agentStore.js

@@ -0,0 +1,113 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from './configStore.js';
+
+const fsPromises = fs.promises;
+
+// Load configuration
+const config = loadConfig();
+const AGENT_ROOT_DIR = config.agentRootDir;
+const AGENT_INFO_DIR = 'agent';
+const AGENT_INFO_FILE = 'info.json';
+const AGENT_INFO_PATH = path.join(
+  os.homedir(),
+  AGENT_ROOT_DIR,
+  AGENT_INFO_DIR,
+  AGENT_INFO_FILE
+);
+
+/**
+ * Agent Store for managing persistent agent information
+ */
+class AgentStore {
+  constructor() {
+    this.agentInfo = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the store
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Ensure directory exists
+      await fsPromises.mkdir(path.dirname(AGENT_INFO_PATH), { recursive: true });
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize agent store:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Save agent start time
+   */
+  async saveAgentStartTime(startTime) {
+    await this.initialize();
+
+    const agentInfo = {
+      startTime: startTime.toISOString(),
+      lastUpdated: new Date().toISOString(),
+    };
+
+    try {
+      await fsPromises.writeFile(AGENT_INFO_PATH, JSON.stringify(agentInfo, null, 2));
+      this.agentInfo = agentInfo;
+    } catch (error) {
+      console.error('Failed to save agent start time:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load agent start time
+   */
+  async loadAgentStartTime() {
+    await this.initialize();
+
+    try {
+      const data = await fsPromises.readFile(AGENT_INFO_PATH, 'utf8');
+      const agentInfo = JSON.parse(data);
+      this.agentInfo = agentInfo;
+      return new Date(agentInfo.startTime);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist - agent not running or first time
+        return null;
+      }
+      console.error('Failed to load agent start time:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Clear agent info (when agent stops)
+   */
+  async clearAgentInfo() {
+    await this.initialize();
+
+    try {
+      await fsPromises.unlink(AGENT_INFO_PATH);
+      this.agentInfo = null;
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error('Failed to clear agent info:', error);
+      }
+    }
+  }
+
+  /**
+   * Check if agent is currently running based on stored info
+   */
+  async isAgentRunning() {
+    const startTime = await this.loadAgentStartTime();
+    return startTime !== null;
+  }
+}
+
+// Export singleton instance
+const agentStore = new AgentStore();
+export default agentStore;