@kodus/cli 0.0.11 → 0.1.0

package/src/commands/install.js

@@ -1,324 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import ora from "ora";
-import fs from "fs-extra";
-import path from "path";
-import { execSync } from "child_process";
-import { DEFAULT_CONFIG, DOCKER_NETWORKS, CRITICAL_ERRORS } from "../config/default.js";
-import {
-  generateSecretKey,
-  generateDbPassword,
-  copyTemplates,
-  createDockerNetworks,
-} from "../utils/helpers.js";
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const maxAttempts = 30; // 5 minutes with 10 second intervals
-
-const waitForService = async (serviceName, successMessage, errorMessage) => {
-  const spinner = ora(`Waiting for ${serviceName} to be ready`).start();
-  let isReady = false;
-  let attempts = 0;
-
-  while (!isReady && attempts < maxAttempts) {
-    try {
-      const logs = execSync(`docker-compose logs ${serviceName}`, { stdio: "pipe" }).toString();
-      
-      if (logs.includes(successMessage)) {
-        isReady = true;
-        spinner.succeed(`${serviceName} is ready`);
-      } else {
-        attempts++;
-        await new Promise(resolve => setTimeout(resolve, 10000));
-      }
-    } catch (error) {
-      attempts++;
-      await new Promise(resolve => setTimeout(resolve, 10000));
-    }
-  }
-
-  if (!isReady) {
-    spinner.fail(errorMessage);
-    console.error(chalk.yellow("\nTroubleshooting steps:"));
-    console.error(chalk.white(`1. Check ${serviceName} logs: docker-compose logs ${serviceName}`));
-    console.error(chalk.white(`2. Verify ${serviceName} container is running: docker-compose ps ${serviceName}`));
-    process.exit(1);
-  }
-};
-
-export const setupEnvironment = async () => {
-  try {
-    // Check prerequisites
-    console.log(chalk.blue("\n🔍 Checking prerequisites..."));
-    const spinner = ora("Checking Docker installation").start();
-
-    try {
-      execSync("docker --version", { stdio: "ignore" });
-      spinner.succeed("Docker is installed");
-    } catch (error) {
-      spinner.fail("Docker is not installed");
-      console.error(
-        chalk.red(
-          "\nPlease install Docker first: https://docs.docker.com/get-docker/"
-        )
-      );
-      process.exit(1);
-    }
-
-    // Copy template files
-    const templateSpinner = ora("Copying template files").start();
-    try {
-      copyTemplates(process.cwd());
-      templateSpinner.succeed("Template files copied");
-    } catch (error) {
-      templateSpinner.fail("Failed to copy template files");
-      console.error(chalk.red("\nError details:"));
-      console.error(chalk.white(error.message));
-      process.exit(1);
-    }
-
-    // Environment type selection
-    const { envType } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "envType",
-        message: "What type of environment are you setting up?",
-        choices: [
-          { name: "Local (localhost)", value: "local" },
-          { name: "External (with public URL)", value: "external" },
-        ],
-        default: "local",
-      },
-    ]);
-
-    let baseUrl = "http://localhost:3000";
-    if (envType === "external") {
-      const { url } = await inquirer.prompt([
-        {
-          type: "input",
-          name: "url",
-          message: "Enter your public URL (e.g., https://kodus.yourdomain.com):",
-          validate: (input) => {
-            try {
-              const url = new URL(input);
-              if (!url.protocol.startsWith('http')) {
-                return "URL must start with http:// or https://";
-              }
-              if (!url.hostname.includes('.')) {
-                return "URL must include a valid domain name";
-              }
-              return true;
-            } catch (e) {
-              return "Please enter a valid URL (e.g., https://kodus.yourdomain.com)";
-            }
-          },
-        },
-      ]);
-      baseUrl = url;
-    }
-
-    // Git service selection
-    const { gitService } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "gitService",
-        message: "Which Git service will you use?",
-        choices: [
-          { name: "GitHub", value: "github" },
-          { name: "GitLab", value: "gitlab" },
-          { name: "Bitbucket", value: "bitbucket" },
-        ],
-      },
-    ]);
-
-    // Git service configuration
-    let gitConfig = {};
-    
-    if (envType === "local") {
-      console.log(chalk.yellow("\n⚠️  IMPORTANT: If you're using a cloud Git service (GitHub, GitLab, Bitbucket), you'll need to configure the webhook manually."));
-      console.log(chalk.yellow("For local or self-hosted Git instances, no additional configuration is needed."));
-      console.log(chalk.yellow("The webhook URL will be:"));
-      console.log(chalk.white(`${baseUrl}/api/webhook/${gitService}`));
-    }
-
-    // Configure webhook URL based on the selected Git service
-    if (gitService === "github") {
-      gitConfig = {
-        API_GITHUB_CODE_MANAGEMENT_WEBHOOK: `${baseUrl}/api/webhook/${gitService}`,
-      };
-    } else if (gitService === "gitlab") {
-      gitConfig = {
-        API_GITLAB_CODE_MANAGEMENT_WEBHOOK: `${baseUrl}/api/webhook/${gitService}`,
-      };
-    } else if (gitService === "bitbucket") {
-      gitConfig = {
-        GLOBAL_BITBUCKET_CODE_MANAGEMENT_WEBHOOK: `${baseUrl}/api/webhook/${gitService}`,
-      };
-    }
-
-    // Database configuration
-    const { useDefaultDb } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "useDefaultDb",
-        message: "Would you like to use default database configurations?",
-        default: true,
-      },
-    ]);
-
-    // LLM API Keys configuration
-    console.log(chalk.blue("\n🔑 Configuring LLM API Keys..."));
-    const llmKeys = await inquirer.prompt([
-      {
-        type: "input",
-        name: "openAiKey",
-        message: "Enter your OpenAI API key (optional):",
-        default: "",
-      },
-      {
-        type: "input",
-        name: "googleAiKey",
-        message: "Enter your Google AI API key (optional):",
-        default: "",
-      },
-      {
-        type: "input",
-        name: "anthropicKey",
-        message: "Enter your Anthropic API key (optional):",
-        default: "",
-      },
-      {
-        type: "input",
-        name: "novitaKey",
-        message: "Enter your Novita AI API key (optional):",
-        default: "",
-      },
-      {
-        type: "input",
-        name: "vertexKey",
-        message: "Enter your Vertex AI API key (optional):",
-        default: "",
-      },
-    ]);
-
-    // Generate .env content
-    const envContent = {
-      ...DEFAULT_CONFIG,
-      WEB_NEXTAUTH_SECRET: generateSecretKey(),
-      WEB_JWT_SECRET_KEY: generateSecretKey(),
-      API_JWT_SECRET: generateSecretKey(),
-      API_JWT_REFRESHSECRET: generateSecretKey(),
-      API_PG_DB_PASSWORD: generateDbPassword(),
-      API_MG_DB_PASSWORD: generateDbPassword(),
-      RABBITMQ_DEFAULT_PASS: generateDbPassword(),
-      GRAFANA_ADMIN_PASSWORD: generateDbPassword(),
-      API_OPEN_AI_APIKEY: llmKeys.openAiKey,
-      API_GOOGLE_AI_API_KEY: llmKeys.googleAiKey,
-      API_ANTHROPIC_API_KEY: llmKeys.anthropicKey,
-      API_NOVITA_AI_API_KEY: llmKeys.novitaKey,
-      API_VERTEX_AI_API_KEY: llmKeys.vertexKey,
-      ...gitConfig,
-    };
-
-    // Create .env file
-    const envSpinner = ora("Creating .env file").start();
-    const envContentString = Object.entries(envContent)
-      .map(([key, value]) => `${key}=${value}`)
-      .join("\n");
-    
-    const envPath = path.join(process.cwd(), '.env');
-    fs.writeFileSync(envPath, envContentString);
-    envSpinner.succeed("Created .env file");
-
-    // Create Docker networks
-    createDockerNetworks(DOCKER_NETWORKS);
-
-    // Start containers
-    const dockerSpinner = ora("Starting containers").start();
-    try {
-      execSync("docker-compose up -d", { stdio: "pipe" });
-      dockerSpinner.succeed("Containers started");
-    } catch (error) {
-      dockerSpinner.fail("Failed to start containers");
-      console.error(chalk.red("\nError details:"));
-      console.error(chalk.white(error.stdout?.toString() || error.message));
-      process.exit(1);
-    }
-
-    // Wait for services to be ready
-    await waitForService(
-      "db_kodus_postgres",
-      "database system is ready to accept connections",
-      "PostgreSQL failed to start"
-    );
-
-    await waitForService(
-      "db_kodus_mongodb",
-      "Waiting for connections",
-      "MongoDB failed to start"
-    );
-
-    // Setup database
-    const dbSpinner = ora("Setting up database").start();
-    try {
-      const moduleRoot = dirname(dirname(__dirname)); // Sobe 2 níveis: commands -> src -> root
-      const scriptPath = path.join(moduleRoot, 'scripts', 'setup-db.sh');
-      
-      if (!fs.existsSync(scriptPath)) {
-        dbSpinner.fail('setup-db.sh script not found!');
-        console.error(chalk.red(`\nScript expected at: ${scriptPath}`));
-        process.exit(1);
-      }
-
-      execSync(`sh ${scriptPath}`, { stdio: "pipe" });
-      dbSpinner.succeed("Database setup completed");
-    } catch (error) {
-      dbSpinner.fail("Failed to setup database");
-      console.error(chalk.red("\nError details:"));
-      console.error(chalk.white(error.stdout?.toString() || error.message));
-      process.exit(1);
-    }
-
-    // Installation complete
-    console.log(chalk.green("\n✨ Installation completed successfully!"));
-
-    console.log(chalk.blue("\n📝 Installation Summary:"));
-    console.log(chalk.white(`  - Environment: ${envType === "local" ? "Local" : "External"}`));
-    if (envType === "external") {
-      console.log(chalk.white(`  - Base URL: ${baseUrl}`));
-    }
-    console.log(chalk.white(`  - Git Service: ${gitService.charAt(0).toUpperCase() + gitService.slice(1)}`));
-    console.log(chalk.white(`  - Database: ${useDefaultDb ? "Default configuration" : "Custom configuration"}`));
-
-    console.log(chalk.blue("\n🔗 Access URLs:"));
-    console.log(chalk.white(`  - Web Interface: ${baseUrl}`));
-    console.log(chalk.white("  - Grafana Dashboard: http://localhost:3001"));
-    console.log(chalk.white("  - RabbitMQ Management: http://localhost:15672"));
-
-    console.log(chalk.blue("\n📚 Next Steps:"));
-    console.log(chalk.white("  1. Access the web interface"));
-    console.log(chalk.white("  2. Set up your first user"));
-    console.log(chalk.white("  3. Start using Kodus!"));
-
-    const { startServices } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "startServices",
-        message: "Would you like to start the services now?",
-        default: true,
-      },
-    ]);
-
-    if (startServices) {
-      execSync("docker-compose up -d", { stdio: "ignore" });
-      console.log(chalk.green("\nServices started successfully!"));
-    }
-  } catch (error) {
-    console.error(chalk.red("\n❌ Installation failed:"), error.message);
-    process.exit(1);
-  }
-}; 

package/src/config/default.js

@@ -1,66 +0,0 @@
-export const DEFAULT_CONFIG = {
-  // Base configuration
-  WEB_NODE_ENV: "development",
-  WEB_HOSTNAME_API: "localhost",
-  WEB_PORT_API: "3001",
-  WEB_PORT: "3000",
-  WEB_NEXTAUTH_URL: "http://localhost:3000",
-  
-  API_NODE_ENV: "development",
-  API_LOG_LEVEL: "error",
-  API_LOG_PRETTY: "true",
-  API_HOST: "0.0.0.0",
-  API_PORT: "3001",
-  API_RATE_MAX_REQUEST: "100",
-  API_RATE_INTERVAL: "1000",
-  API_JWT_EXPIRES_IN: "365d",
-  API_JWT_REFRESH_EXPIRES_IN: "7d",
-  
-  GLOBAL_API_CONTAINER_NAME: "kodus-orchestrator-prod",
-
-  // Database
-  API_DATABASE_ENV: "development",
-  API_PG_DB_USERNAME: "kodusdev",
-  API_PG_DB_DATABASE: "kodus_db",
-  API_PG_DB_HOST: "db_kodus_postgres",
-  API_PG_DB_PORT: "5432",
-
-  API_MG_DB_USERNAME: "kodusdev",
-  API_MG_DB_DATABASE: "kodus_db",
-  API_MG_DB_HOST: "db_kodus_mongodb",
-  API_MG_DB_PORT: "27017",
-  API_MG_DB_PRODUCTION_CONFIG: "",
-
-  // LLM Models
-  API_LLM_MODEL_CHATGPT_3_5_TURBO: "gpt-4o-mini",
-  API_LLM_MODEL_CHATGPT_3_5_TURBO_16K: "gpt-4o-mini",
-  API_LLM_MODEL_CHATGPT_4: "gpt-4o-mini",
-  API_LLM_MODEL_CHATGPT_4_TURBO: "gpt-4o-mini",
-  API_LLM_MODEL_CHATGPT_4_ALL: "gpt-4o",
-  API_LLM_MODEL_CHATGPT_4_ALL_MINI: "gpt-4o-mini",
-  API_LLM_MODEL_CLAUDE_3_5_SONNET: "claude-3-5-sonnet-20241022",
-  API_LLM_MODEL_CLAUDE_3_5_SONNET_20241022: "claude-3-5-sonnet-20241022",
-  API_LLM_MODEL_GEMINI_1_5_PRO: "gpt-4o-mini",
-  API_LLM_MODEL_GEMINI_1_5_PRO_EXP: "gpt-4o-mini",
-
-  // Ports
-  WEB_PORT: "3000",
-  API_PORT: "3001",
-
-  // RabbitMQ
-  RABBITMQ_DEFAULT_USER: "kodus",
-};
-
-export const DOCKER_NETWORKS = [
-  'shared-network',
-  'monitoring-network',
-  'kodus-backend-services'
-];
-
-export const CRITICAL_ERRORS = [
-  "password authentication failed",
-  "Unable to connect to the database",
-  "FATAL:",
-  "MongoServerError:",
-  "connection refused"
-]; 

package/src/utils/helpers.js

@@ -1,118 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs-extra';
-import path from 'path';
-import { execSync } from 'child_process';
-import ora from 'ora';
-import chalk from 'chalk';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export const generateSecretKey = () => crypto.randomBytes(32).toString("base64");
-
-export const generateDbPassword = () =>
-  crypto
-    .randomBytes(16)
-    .toString("base64")
-    .replace(/[^a-zA-Z0-9]/g, "")
-    .slice(0, 16);
-
-export const copyTemplates = (targetDir) => {
-  try {
-    const moduleDir = dirname(dirname(dirname(__filename))); // Sobe 3 níveis: utils -> src -> root
-    const templatesDir = path.join(moduleDir, 'templates');
-    
-    if (!fs.existsSync(templatesDir)) {
-      console.error(chalk.red(`Templates directory not found at: ${templatesDir}`));
-      console.error(chalk.yellow('Current directory structure:'));
-      console.error(chalk.white(fs.readdirSync(moduleDir)));
-      throw new Error('Templates directory not found');
-    }
-    
-    const sourceFile = path.join(templatesDir, 'docker-compose.yml');
-    const targetFile = path.join(targetDir, 'docker-compose.yml');
-    
-    if (!fs.existsSync(sourceFile)) {
-      console.error(chalk.red(`Template file not found at: ${sourceFile}`));
-      console.error(chalk.yellow('Files in templates directory:'));
-      console.error(chalk.white(fs.readdirSync(templatesDir)));
-      throw new Error('Template file not found');
-    }
-    
-    fs.copySync(sourceFile, targetFile);
-  } catch (error) {
-    console.error(chalk.red('Error copying templates:'), error);
-    throw error;
-  }
-};
-
-export const backupEnv = () => {
-  const envPath = path.join(process.cwd(), '.env');
-  if (fs.existsSync(envPath)) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const backupPath = path.join(process.cwd(), `.env.backup.${timestamp}`);
-    fs.copySync(envPath, backupPath);
-    return true;
-  }
-  return false;
-};
-
-export const restoreEnv = (backupFile) => {
-  const backupPath = path.join(process.cwd(), backupFile);
-  if (fs.existsSync(backupPath)) {
-    const envPath = path.join(process.cwd(), '.env');
-    fs.copySync(backupPath, envPath);
-    return true;
-  }
-  return false;
-};
-
-export const getLatestVersion = () => {
-  try {
-    const result = execSync("git describe --tags --abbrev=0", { stdio: "pipe" })
-      .toString()
-      .trim();
-    return result;
-  } catch (error) {
-    return null;
-  }
-};
-
-export const getCurrentVersion = () => {
-  try {
-    const result = execSync("git rev-parse --abbrev-ref HEAD", {
-      stdio: "pipe",
-    })
-      .toString()
-      .trim();
-    return result;
-  } catch (error) {
-    return null;
-  }
-};
-
-export const createDockerNetworks = (networks) => {
-  const networkSpinner = ora("Creating Docker networks").start();
-  
-  for (const network of networks) {
-    try {
-      // Check if network exists
-      execSync(`docker network inspect ${network}`, { stdio: 'ignore' });
-    } catch (error) {
-      // Network doesn't exist, create it
-      try {
-        execSync(`docker network create ${network}`, { stdio: 'pipe' });
-        console.log(chalk.green(`\nCreated network: ${network}`));
-      } catch (createError) {
-        networkSpinner.fail(`Failed to create network: ${network}`);
-        console.error(chalk.red("\nError details:"));
-        console.error(chalk.white(createError.stdout?.toString() || createError.message));
-        process.exit(1);
-      }
-    }
-  }
-  
-  networkSpinner.succeed("Docker networks created");
-}; 

package/templates/docker-compose.yml

@@ -1,139 +0,0 @@
-services:
-  kodus-web:
-    image: ghcr.io/kodustech/kodus-web:latest
-    container_name: kodus-web-prod
-    ports:
-      - "${WEB_PORT}:${WEB_PORT}"
-    networks:
-      - shared-network
-      - kodus-backend-services
-    restart: unless-stopped
-    env_file:
-      - .env
-
-  kodus-orchestrator:
-    image: ghcr.io/kodustech/kodus-ai:latest
-    platform: linux/amd64
-    container_name: ${GLOBAL_API_CONTAINER_NAME}
-    volumes:
-      - log_volume:/app/logs
-    logging:
-      options:
-        max-size: "200m"
-        max-file: "10"
-    ports:
-      - "3001:3001"
-      - "9229:9229"
-    environment:
-      - ENV=production
-      - NODE_ENV=production
-    networks:
-      - shared-network
-      - kodus-backend-services
-    restart: unless-stopped
-    env_file:
-      - .env
-
-  rabbitmq:
-    image: rabbitmq:3.13.4-management-alpine
-    container_name: rabbitmq-prod
-    hostname: rabbitmq
-    ports:
-      - "5672:5672"
-      - "15672:15672"
-    networks:
-      - monitoring-network
-      - shared-network
-    environment:
-      - RABBITMQ_SERVER_ADDITIONAL_ERL_ARGS=-rabbit heartbeat 60
-    restart: unless-stopped
-    env_file:
-      - .env
-
-  db_kodus_postgres:
-    image: pgvector/pgvector:pg16
-    container_name: db_kodus_postgres
-    ports:
-      - "5432:5432"
-    environment:
-      POSTGRES_USER: ${API_PG_DB_USERNAME}
-      POSTGRES_PASSWORD: ${API_PG_DB_PASSWORD}
-      POSTGRES_DB: ${API_PG_DB_DATABASE}
-    volumes:
-      - pgdata:/var/lib/postgresql/data
-      - ./docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d
-    networks:
-      - kodus-backend-services
-
-  db_kodus_mongodb:
-    image: mongo:8
-    container_name: db_kodus_mongodb
-    ports:
-      - "27017:27017"
-    volumes:
-      - mongodbdata:/data/db
-    environment:
-      # These variables must be defined in the .env file
-      MONGO_INITDB_ROOT_USERNAME: ${API_MG_DB_USERNAME}
-      MONGO_INITDB_ROOT_PASSWORD: ${API_MG_DB_PASSWORD}
-      MONGO_INITDB_DATABASE: ${API_MG_DB_DATABASE}
-    networks:
-      - kodus-backend-services
-
-  migration:
-    image: ghcr.io/kodustech/kodus-ai:latest
-    platform: linux/amd64
-    container_name: migration
-    depends_on:
-      - db_kodus_postgres
-    environment:
-      - ENV=${API_DATABASE_ENV}
-      - NODE_ENV=${API_NODE_ENV}
-      - API_PG_DB_HOST=${API_PG_DB_HOST}
-      - API_PG_DB_PORT=${API_PG_DB_PORT}
-      - API_PG_DB_USERNAME=${API_PG_DB_USERNAME}
-      - API_PG_DB_PASSWORD=${API_PG_DB_PASSWORD}
-      - API_PG_DB_DATABASE=${API_PG_DB_DATABASE}
-      - PGSSLMODE=disable
-    command: >
-      sh -c '
-        echo "Debug: Printing environment variables..." &&
-        echo "API_PG_DB_HOST=" $$API_PG_DB_HOST &&
-        echo "Creating temporary datasource file..." &&
-        echo "const { DataSource } = require(\"typeorm\");
-        module.exports = new DataSource({
-          type: \"postgres\",
-          host: \"db_kodus_postgres\",
-          port: 5432,
-          username: \"$$API_PG_DB_USERNAME\",
-          password: \"$$API_PG_DB_PASSWORD\",
-          database: \"$$API_PG_DB_DATABASE\",
-          ssl: false,
-          entities: [\"./dist/modules/**/infra/typeorm/entities/*.js\"],
-          migrations: [\"./dist/config/database/typeorm/migrations/*.js\"]
-        });" > datasource.js &&
-        yarn typeorm migration:run -d datasource.js
-      '
-    networks:
-      - kodus-backend-services
-    env_file:
-      - .env
-
-volumes:
-  log_volume:
-  rabbitmq-data-prod:
-    name: rabbitmq-data-prod
-  pgdata:
-  mongodbdata:
-
-networks:
-  shared-network:
-    external: true
-  monitoring-network:
-    driver: bridge
-    name: monitoring-network
-    external: true
-  kodus-backend-services:
-    driver: bridge
-    name: kodus-backend-services
-    external: true