@oussema_mili/test-pkg-123 1.1.32

package/postcss.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};

package/scripts/release.sh

@@ -0,0 +1,212 @@
+#!/bin/bash
+
+# Fenwave Agent Release Script
+# Usage: ./scripts/release.sh [patch|minor|major|x.x.x]
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Functions
+log_info() { echo -e "${BLUE}ℹ ${NC}$1"; }
+log_success() { echo -e "${GREEN}✓ ${NC}$1"; }
+log_warning() { echo -e "${YELLOW}⚠ ${NC}$1"; }
+log_error() { echo -e "${RED}✗ ${NC}$1"; exit 1; }
+
+# Check prerequisites
+check_prerequisites() {
+    log_info "Checking prerequisites..."
+
+    command -v node >/dev/null 2>&1 || log_error "Node.js is required"
+    command -v npm >/dev/null 2>&1 || log_error "npm is required"
+    command -v gh >/dev/null 2>&1 || log_error "GitHub CLI (gh) is required"
+    command -v git >/dev/null 2>&1 || log_error "git is required"
+
+    # Check if logged into npm
+    npm whoami >/dev/null 2>&1 || log_error "Not logged into npm. Run 'npm login' first"
+
+    # Check if logged into GitHub CLI
+    gh auth status >/dev/null 2>&1 || log_error "Not logged into GitHub CLI. Run 'gh auth login' first"
+
+    # Check for uncommitted changes
+    if [[ -n $(git status --porcelain) ]]; then
+        log_error "Working directory has uncommitted changes. Commit or stash them first"
+    fi
+
+    # Check we're on main branch
+    CURRENT_BRANCH=$(git branch --show-current)
+    if [[ "$CURRENT_BRANCH" != "main" ]]; then
+        log_warning "Not on main branch (currently on: $CURRENT_BRANCH)"
+        read -p "Continue anyway? (y/N) " -n 1 -r
+        echo
+        [[ ! $REPLY =~ ^[Yy]$ ]] && exit 1
+    fi
+
+    # Pull latest changes
+    log_info "Pulling latest changes..."
+    git pull origin "$CURRENT_BRANCH"
+
+    log_success "Prerequisites check passed"
+}
+
+# Get version argument
+get_version() {
+    VERSION_ARG=$1
+    CURRENT_VERSION=$(node -p "require('./package.json').version")
+
+    if [[ -z "$VERSION_ARG" ]]; then
+        echo "" >&2
+        echo "Current version: $CURRENT_VERSION" >&2
+        echo "" >&2
+        echo "Select version bump:" >&2
+        echo "  1) patch (x.x.X) - Bug fixes" >&2
+        echo "  2) minor (x.X.0) - New features" >&2
+        echo "  3) major (X.0.0) - Breaking changes" >&2
+        echo "  4) custom - Enter specific version" >&2
+        echo "" >&2
+        read -p "Choice [1-4]: " choice
+
+        case $choice in
+            1) VERSION_ARG="patch" ;;
+            2) VERSION_ARG="minor" ;;
+            3) VERSION_ARG="major" ;;
+            4) read -p "Enter version (e.g., 1.2.3): " VERSION_ARG ;;
+            *) log_error "Invalid choice" ;;
+        esac
+    fi
+
+    echo "$VERSION_ARG"
+}
+
+# Bump version
+bump_version() {
+    local VERSION_TYPE=$1
+
+    log_info "Bumping version ($VERSION_TYPE)..." >&2
+
+    if [[ "$VERSION_TYPE" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        # Specific version provided
+        npm version "$VERSION_TYPE" --no-git-tag-version >/dev/null
+    else
+        # patch, minor, or major
+        npm version "$VERSION_TYPE" --no-git-tag-version >/dev/null
+    fi
+
+    NEW_VERSION=$(node -p "require('./package.json').version")
+    log_success "Version bumped to $NEW_VERSION" >&2
+
+    echo "$NEW_VERSION"
+}
+
+# Commit and tag
+commit_and_tag() {
+    local VERSION=$1
+
+    log_info "Committing version bump..."
+
+    git add package.json package-lock.json 2>/dev/null || git add package.json
+    git commit -m "chore: release v$VERSION"
+
+    log_info "Creating git tag v$VERSION..."
+    git tag -a "v$VERSION" -m "Release v$VERSION"
+
+    log_success "Committed and tagged"
+}
+
+# Push to remote
+push_to_remote() {
+    local VERSION=$1
+
+    log_info "Pushing to remote..."
+
+    git push origin "$(git branch --show-current)"
+    git push origin "v$VERSION"
+
+    log_success "Pushed to remote"
+}
+
+# Create GitHub release
+create_github_release() {
+    local VERSION=$1
+
+    log_info "Creating GitHub release..."
+
+    # Get commits since last tag
+    LAST_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+
+    if [[ -n "$LAST_TAG" ]]; then
+        CHANGES=$(git log "$LAST_TAG"..HEAD --pretty=format:"- %s" --no-merges | grep -v "chore: release")
+    else
+        CHANGES="- Initial release"
+    fi
+
+    # Create release notes
+    RELEASE_NOTES="## What's Changed
+
+$CHANGES
+
+**Full Changelog**: https://github.com/$(gh repo view --json nameWithOwner -q .nameWithOwner)/compare/${LAST_TAG:-v0.0.0}...v$VERSION"
+
+    gh release create "v$VERSION" \
+        --title "v$VERSION" \
+        --notes "$RELEASE_NOTES"
+
+    log_success "GitHub release created"
+}
+
+# Publish to npm
+publish_to_npm() {
+    log_info "Publishing to npm..."
+
+    # Check if OTP is needed
+    read -p "Enter npm OTP (leave empty if not using 2FA): " OTP
+
+    if [[ -n "$OTP" ]]; then
+        npm publish --access public --otp="$OTP"
+    else
+        npm publish --access public
+    fi
+
+    log_success "Published to npm"
+}
+
+# Main
+main() {
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "       Fenwave Agent Release Script"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    check_prerequisites
+
+    VERSION_ARG=$(get_version "$1")
+    NEW_VERSION=$(bump_version "$VERSION_ARG")
+
+    echo ""
+    log_info "Ready to release v$NEW_VERSION"
+    read -p "Continue with release? (y/N) " -n 1 -r
+    echo ""
+    [[ ! $REPLY =~ ^[Yy]$ ]] && { log_warning "Release cancelled"; exit 0; }
+
+    commit_and_tag "$NEW_VERSION"
+    push_to_remote "$NEW_VERSION"
+    create_github_release "$NEW_VERSION"
+    publish_to_npm
+
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "${GREEN}  Release v$NEW_VERSION completed successfully!${NC}"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "  npm: https://www.npmjs.com/package/@fenwave/agent"
+    echo "  GitHub: $(gh repo view --json url -q .url)/releases/tag/v$NEW_VERSION"
+    echo ""
+}
+
+main "$@"

package/setup/setupWizard.js

@@ -0,0 +1,403 @@
+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 {
+  saveSetupProgress,
+  clearSetupState,
+  SetupStep,
+  isSetupInProgress,
+} from "../store/setupState.js";
+import { initializeConfig } from "../store/configStore.js";
+
+const TOTAL_STEPS = 5; // Reduced - no ECR auth or NPM config needed (public package and GHCR)
+
+/**
+ * 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.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,
+      };
+
+      initializeConfig(agentConfig);
+
+      displayInfo("Agent configuration initialized:");
+      displayKeyValue({
+        "Backend URL": this.backendUrl,
+        "Frontend URL": this.frontendUrl,
+      });
+      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: Pull DevApp Image (GHCR is public, no auth required)
+      await this.pullImageStep(registrationData);
+
+      // Step 4: Start Agent (optional)
+      await this.startAgentStep();
+
+      // Step 5: 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 Fenwave...",
+      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,
+        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: Pull Fenwave DevApp Image (GHCR is public, no auth required)
+   */
+  async pullImageStep(registrationData) {
+    displayStep(3, 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 4: Start Agent (optional)
+   */
+  async startAgentStep() {
+    displayStep(4, 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(5, 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,
+};