@edgible-team/cli 1.0.1

package/dist/di/bindings.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Dependency injection bindings
+ * Registers all services with the container
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindServices = bindServices;
+exports.initializeContainer = initializeContainer;
+const container_1 = require("./container");
+const types_1 = require("./types");
+const console_logger_1 = require("../utils/console-logger");
+const app_config_1 = require("../config/app-config");
+const config_1 = require("../state/config");
+const edgible_1 = require("../services/edgible");
+const LocalAgentManager_1 = require("../services/LocalAgentManager");
+const ConnectivityTester_1 = require("../services/ConnectivityTester");
+const WorkloadDetector_1 = require("../detection/WorkloadDetector");
+const ToolDetector_1 = require("../detection/ToolDetector");
+const logger_1 = require("../utils/logger");
+const config_repository_1 = require("../repositories/config-repository");
+const gateway_repository_1 = require("../repositories/gateway-repository");
+const AuthService_1 = require("../services/auth/AuthService");
+const ApplicationService_1 = require("../services/application/ApplicationService");
+const GatewayService_1 = require("../services/gateway/GatewayService");
+/**
+ * Bind all services to the container
+ */
+function bindServices(container = (0, container_1.getContainer)()) {
+    // Bind configuration
+    container.bind(types_1.TYPES.AppConfig, () => (0, app_config_1.getConfig)(), true);
+    // Bind logger
+    container.bind(types_1.TYPES.Logger, () => {
+        const config = container.get(types_1.TYPES.AppConfig);
+        const logger = new console_logger_1.ConsoleLogger({
+            level: (0, logger_1.parseLogLevel)(config.logLevel),
+            colorEnabled: config.colorEnabled,
+            plain: config.plain,
+        });
+        return logger;
+    }, true);
+    // Bind ConfigManager
+    container.bind(types_1.TYPES.ConfigManager, () => new config_1.ConfigManager(), true);
+    // Bind Repositories
+    container.bind(types_1.TYPES.ConfigRepository, () => {
+        const configManager = container.get(types_1.TYPES.ConfigManager);
+        return new config_repository_1.ConfigRepositoryImpl(configManager);
+    }, true);
+    container.bind(types_1.TYPES.GatewayRepository, () => {
+        const configManager = container.get(types_1.TYPES.ConfigManager);
+        return new gateway_repository_1.GatewayRepositoryImpl(configManager);
+    }, true);
+    // Bind AuthService
+    container.bind(types_1.TYPES.AuthService, () => {
+        const config = container.get(types_1.TYPES.AppConfig);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const logger = container.get(types_1.TYPES.Logger);
+        return new AuthService_1.AuthServiceImpl(config.apiBaseUrl, configRepository, logger);
+    }, true);
+    // Bind ApplicationService
+    container.bind(types_1.TYPES.ApplicationService, () => {
+        const config = container.get(types_1.TYPES.AppConfig);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const logger = container.get(types_1.TYPES.Logger);
+        return new ApplicationService_1.ApplicationServiceImpl(config.apiBaseUrl, configRepository, authService, logger);
+    }, true);
+    // Bind GatewayService
+    container.bind(types_1.TYPES.GatewayService, () => {
+        const config = container.get(types_1.TYPES.AppConfig);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const gatewayRepository = container.get(types_1.TYPES.GatewayRepository);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const logger = container.get(types_1.TYPES.Logger);
+        return new GatewayService_1.GatewayServiceImpl(config.apiBaseUrl, configRepository, gatewayRepository, authService, logger);
+    }, true);
+    // Bind EdgibleService
+    container.bind(types_1.TYPES.EdgibleService, () => {
+        const config = container.get(types_1.TYPES.AppConfig);
+        return new edgible_1.EdgibleService(config.apiBaseUrl);
+    }, true);
+    // Bind LocalAgentManager
+    container.bind(types_1.TYPES.LocalAgentManager, () => new LocalAgentManager_1.LocalAgentManager(), true);
+    // Bind ConnectivityTester
+    container.bind(types_1.TYPES.ConnectivityTester, () => new ConnectivityTester_1.ConnectivityTester(), false);
+    // Bind WorkloadDetector
+    container.bind(types_1.TYPES.WorkloadDetector, () => new WorkloadDetector_1.WorkloadDetector(), false);
+    // Bind ToolDetector
+    container.bind(types_1.TYPES.ToolDetector, () => ToolDetector_1.ToolDetector, true);
+}
+/**
+ * Initialize container with all bindings
+ * Should be called once at application startup
+ */
+function initializeContainer() {
+    const container = (0, container_1.getContainer)();
+    bindServices(container);
+    return container;
+}
+//# sourceMappingURL=bindings.js.map

package/dist/di/container.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Simple dependency injection container
+ * Supports singleton and transient bindings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+exports.getContainer = getContainer;
+exports.setContainer = setContainer;
+exports.resetContainer = resetContainer;
+class Container {
+    constructor() {
+        this.bindings = new Map();
+        this.singletons = new Map();
+    }
+    /**
+     * Register a service binding
+     */
+    bind(identifier, factory, singleton = true) {
+        this.bindings.set(identifier, { factory, singleton });
+    }
+    /**
+     * Get a service instance
+     */
+    get(identifier) {
+        const binding = this.bindings.get(identifier);
+        if (!binding) {
+            throw new Error(`Service not bound: ${identifier.toString()}`);
+        }
+        if (binding.singleton) {
+            if (!this.singletons.has(identifier)) {
+                const instance = binding.factory();
+                this.singletons.set(identifier, instance);
+            }
+            return this.singletons.get(identifier);
+        }
+        else {
+            return binding.factory();
+        }
+    }
+    /**
+     * Check if a service is bound
+     */
+    isBound(identifier) {
+        return this.bindings.has(identifier);
+    }
+    /**
+     * Clear all bindings and singletons (useful for testing)
+     */
+    reset() {
+        this.bindings.clear();
+        this.singletons.clear();
+    }
+    /**
+     * Unbind a specific service
+     */
+    unbind(identifier) {
+        this.bindings.delete(identifier);
+        this.singletons.delete(identifier);
+    }
+}
+exports.Container = Container;
+/**
+ * Default container instance
+ */
+let defaultContainer = null;
+/**
+ * Get default container instance
+ */
+function getContainer() {
+    if (!defaultContainer) {
+        defaultContainer = new Container();
+    }
+    return defaultContainer;
+}
+/**
+ * Set container instance (useful for testing)
+ */
+function setContainer(container) {
+    defaultContainer = container;
+}
+/**
+ * Reset default container
+ */
+function resetContainer() {
+    defaultContainer = null;
+}
+//# sourceMappingURL=container.js.map

package/dist/di/types.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Dependency injection type identifiers
+ * Uses symbol-based keys for type safety
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPES = void 0;
+exports.TYPES = {
+    // Loggers
+    Logger: Symbol.for('Logger'),
+    // Services
+    EdgibleService: Symbol.for('EdgibleService'),
+    AuthService: Symbol.for('AuthService'),
+    GatewayService: Symbol.for('GatewayService'),
+    ApplicationService: Symbol.for('ApplicationService'),
+    GatewaySshService: Symbol.for('GatewaySshService'),
+    GatewayDiagnosticsService: Symbol.for('GatewayDiagnosticsService'),
+    LocalAgentManager: Symbol.for('LocalAgentManager'),
+    ConnectivityTester: Symbol.for('ConnectivityTester'),
+    AWSService: Symbol.for('AWSService'),
+    // Repositories
+    ConfigRepository: Symbol.for('ConfigRepository'),
+    GatewayRepository: Symbol.for('GatewayRepository'),
+    // Managers
+    ConfigManager: Symbol.for('ConfigManager'),
+    // Detectors
+    WorkloadDetector: Symbol.for('WorkloadDetector'),
+    ToolDetector: Symbol.for('ToolDetector'),
+    // Configuration
+    AppConfig: Symbol.for('AppConfig'),
+};
+//# sourceMappingURL=types.js.map

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const errors_1 = require("./utils/errors");
+const output_1 = require("./utils/output");
+const bindings_1 = require("./di/bindings");
+const application_1 = require("./commands/application");
+const gateway_1 = require("./commands/gateway");
+const auth_1 = require("./commands/auth");
+const config_1 = require("./commands/config");
+const discover_1 = require("./commands/discover");
+const connectivity_1 = require("./commands/connectivity");
+const ai_1 = require("./commands/ai");
+const agent_1 = require("./commands/agent");
+const debug_1 = require("./commands/debug");
+const managedGateway_1 = require("./commands/managedGateway");
+// Initialize dependency injection container
+(0, bindings_1.initializeContainer)();
+const program = new commander_1.Command();
+// Set up the CLI
+program
+    .name('edgible')
+    .description('CLI tool for Edgible service')
+    .version('1.0.0')
+    .configureHelp({
+    helpWidth: 100,
+})
+    .option('--no-color', 'Disable colored output')
+    .option('--plain', 'Plain text output (no colors, no emojis)')
+    .hook('preAction', (thisCommand, actionCommand) => {
+    // Apply output configuration based on global options
+    const opts = thisCommand.opts();
+    (0, output_1.applyOutputConfig)({ noColor: opts.noColor === false, plain: opts.plain === true });
+    // Configure error handler
+    errors_1.ErrorHandler.setColorEnabled((0, output_1.detectColorSupport)() && opts.plain !== true);
+});
+// Set up command groups
+(0, auth_1.setupAuthCommands)(program);
+(0, application_1.setupApplicationCommands)(program);
+(0, gateway_1.setupGatewayCommands)(program);
+(0, config_1.setupConfigCommands)(program);
+(0, discover_1.setupDiscoverCommands)(program);
+(0, connectivity_1.setupConnectivityCommands)(program);
+(0, ai_1.setupAiCommands)(program);
+(0, agent_1.setupAgentCommands)(program);
+if (process.env.NODE_ENV !== 'production') {
+    (0, debug_1.setupDebugCommands)(program);
+    (0, managedGateway_1.setupManagedGatewayCommands)(program);
+}
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map

package/dist/interfaces/IDaemonManager.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IDaemonManager.js.map

package/dist/repositories/config-repository.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Configuration repository
+ * Abstracts config access for better testability and centralized state management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigRepositoryImpl = void 0;
+/**
+ * ConfigRepository implementation using ConfigManager
+ */
+class ConfigRepositoryImpl {
+    constructor(configManager) {
+        this.configManager = configManager;
+    }
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    updateConfig(updates) {
+        this.configManager.updateConfig(updates);
+    }
+    isFirstRun() {
+        return this.configManager.isFirstRun();
+    }
+    setFirstRunComplete() {
+        this.configManager.setFirstRunComplete();
+    }
+    setEmail(email) {
+        this.configManager.setEmail(email);
+    }
+    getEmail() {
+        return this.configManager.getEmail();
+    }
+    setAccountStatus(exists) {
+        this.configManager.setAccountStatus(exists);
+    }
+    hasAccount() {
+        return this.configManager.hasAccount();
+    }
+    clearConfig() {
+        this.configManager.clearConfig();
+    }
+    setAWSProfile(profile) {
+        this.configManager.setAWSProfile(profile);
+    }
+    getAWSProfile() {
+        return this.configManager.getAWSProfile();
+    }
+    setAWSRegion(region) {
+        this.configManager.setAWSRegion(region);
+    }
+    getAWSRegion() {
+        return this.configManager.getAWSRegion();
+    }
+    setDeviceType(deviceType) {
+        this.configManager.setDeviceType(deviceType);
+    }
+    getDeviceType() {
+        return this.configManager.getDeviceType();
+    }
+}
+exports.ConfigRepositoryImpl = ConfigRepositoryImpl;
+//# sourceMappingURL=config-repository.js.map

package/dist/repositories/gateway-repository.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Gateway repository
+ * Manages gateway state and configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayRepositoryImpl = void 0;
+/**
+ * GatewayRepository implementation using ConfigManager
+ */
+class GatewayRepositoryImpl {
+    constructor(configManager) {
+        this.configManager = configManager;
+    }
+    addGateway(gatewayId, gatewayInfo) {
+        this.configManager.addGateway(gatewayId, gatewayInfo);
+    }
+    getGateway(gatewayId) {
+        return this.configManager.getGateway(gatewayId);
+    }
+    getGateways() {
+        return this.configManager.getGateways();
+    }
+    removeGateway(gatewayId) {
+        this.configManager.removeGateway(gatewayId);
+    }
+    hasGateway(gatewayId) {
+        return this.getGateway(gatewayId) !== undefined;
+    }
+    listGatewayIds() {
+        return Object.keys(this.getGateways());
+    }
+}
+exports.GatewayRepositoryImpl = GatewayRepositoryImpl;
+//# sourceMappingURL=gateway-repository.js.map

package/dist/scripts/postinstall.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+/**
+ * Post-Install Script
+ * 
+ * Displays welcome message and performs basic environment checks after installation.
+ * This runs automatically after `npm install` or `npm install -g edgible-cli`.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Colors for console output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m'
+};
+
+function log(message, color = colors.reset) {
+  console.log(`${color}${message}${colors.reset}`);
+}
+
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.split('.')[0].substring(1));
+  
+  if (major < 16) {
+    log(`\n⚠️  Warning: Node.js ${version} detected. Edgible CLI requires Node.js >=16.0.0`, colors.yellow);
+    log(`   Please upgrade Node.js: https://nodejs.org/\n`, colors.gray);
+    return false;
+  }
+  return true;
+}
+
+function checkIfGlobalInstall() {
+  // Check if running in global node_modules
+  const isGlobal = __dirname.includes('node_modules') && 
+                   (__dirname.includes('/lib/node_modules/') || 
+                    __dirname.includes('\\lib\\node_modules\\'));
+  return isGlobal;
+}
+
+function main() {
+  try {
+    // Skip in CI environments
+    if (process.env.CI || process.env.EDGIBLE_NO_INTERACTIVE) {
+      return;
+    }
+
+    log('\n');
+    log('═══════════════════════════════════════════════════════', colors.cyan);
+    log('  ✨ Welcome to Edgible CLI!', colors.bright + colors.cyan);
+    log('═══════════════════════════════════════════════════════', colors.cyan);
+    log('\n');
+
+    // Check Node.js version
+    const nodeOk = checkNodeVersion();
+
+    // Check if global install
+    const isGlobal = checkIfGlobalInstall();
+
+    if (isGlobal) {
+      log('✅ Edgible CLI installed globally', colors.green);
+      log('\n');
+      log('Quick Start:', colors.bright);
+      log('  1. Run: edgible login', colors.gray);
+      log('  2. Run: edgible --help', colors.gray);
+      log('\n');
+    } else {
+      log('📦 Edgible CLI installed locally', colors.cyan);
+      log('\n');
+      log('Quick Start:', colors.bright);
+      log('  1. Run: npx edgible login', colors.gray);
+      log('  2. Run: npx edgible --help', colors.gray);
+      log('\n');
+      log('For global access, install with: npm install -g edgible-cli', colors.gray);
+      log('\n');
+    }
+
+    log('Documentation: https://edgible.com/docs', colors.cyan);
+    log('Support: https://github.com/edgible/edgible-cli/issues', colors.cyan);
+    log('\n');
+
+  } catch (error) {
+    // Silently fail - post-install scripts should not break installation
+    // Error is logged to npm but won't stop the process
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };
+