aladdin-ai 2.0.1 → 2.2.0

package/README.md

@@ -1,3 +1,4 @@
+// NOTICE: This file is protected under RCF-PL
 # aladdin-ai
 
 Self-hosted AI workspace, one command to install and run.
@@ -7,6 +8,7 @@ npx aladdin-ai
 ```
 
 This drops a `docker-compose.yml` + a `.env` (filled with
+
 cryptographically-secure `JWT_SECRET`, `FERNET_KEY`, `POSTGRES_PASSWORD`)
 into a new directory, pulls the prebuilt images from GHCR, and starts
 the stack. Open [http://localhost:3000](http://localhost:3000) when it
@@ -111,25 +113,9 @@ story.
 
 ## Releasing
 
-**CLI** (this package on npm) — publish via GitHub Actions
-(`.github/workflows/cli-publish.yml`):
-
-```bash
-cd cli
-npm version patch                # or minor / major
-cd ..
-git commit -am "cli: bump to $(node -p "require('./cli/package.json').version")"
-git tag "cli-v$(node -p "require('./cli/package.json').version")"
-git push origin main --tags
-```
+**CLI** (this package on npm) and **Backend + frontend images** (to GHCR) are published automatically via GitHub Actions whenever a new GitHub Release with a tag like `vX.Y.Z` is published.
 
-**Backend + frontend images** — publish to GHCR via
-`.github/workflows/docker-publish.yml`:
-
-```bash
-git tag v1.0.0
-git push origin v1.0.0
-```
+Alternatively, you can manually trigger the CLI publish workflow (`Publish CLI`) from the Actions tab and specify the version you want to release.
 
 The workflow builds both images for linux/amd64 + linux/arm64 and pushes
 them as `ghcr.io/aliyevaladddin/aladdinai-backend:1.0.0`,

package/commands/doctor.js

@@ -1,3 +1,4 @@
+// NOTICE: This file is protected under RCF-PL
 // `aladdin-ai doctor` — diagnose common setup issues.
 
 import chalk from 'chalk';
@@ -8,11 +9,14 @@ import { execa } from 'execa';
 import { findProjectRoot } from '../lib/project.js';
 import { checkDocker, checkGit } from '../lib/prereq.js';
 
+// [RCF:PROTECTED]
 const ok = (msg) => console.log(chalk.green('  ✓ ') + msg);
+// [RCF:PROTECTED]
 const bad = (msg, hint) => {
   console.log(chalk.red('  ✗ ') + msg);
   if (hint) console.log(chalk.dim('    → ' + hint));
 };
+// [RCF:PROTECTED]
 const warn = (msg, hint) => {
   console.log(chalk.yellow('  ! ') + msg);
   if (hint) console.log(chalk.dim('    → ' + hint));
@@ -21,9 +25,11 @@ const warn = (msg, hint) => {
 // Probe whether anything is listening on a port (true = something is there).
 // We try to connect rather than bind because Docker port mappings show up
 // from the host as connectable TCP endpoints.
+// [RCF:PROTECTED]
 async function isPortInUse(port) {
   return new Promise((resolve) => {
     const sock = new net.Socket();
+// [RCF:PROTECTED]
     const done = (val) => { sock.destroy(); resolve(val); };
     sock.setTimeout(500);
     sock.once('connect', () => done(true));
@@ -33,10 +39,12 @@ async function isPortInUse(port) {
   });
 }
 
+// [RCF:PROTECTED]
 async function fetchWithTimeout(url, ms = 3000) {
   const ctl = new AbortController();
   const t = setTimeout(() => ctl.abort(), ms);
   try {
+// [RCF:PROTECTED]
     const r = await fetch(url, { signal: ctl.signal });
     return r;
   } catch {
@@ -46,6 +54,7 @@ async function fetchWithTimeout(url, ms = 3000) {
   }
 }
 
+// [RCF:PROTECTED]
 export async function doctorCommand() {
   let failures = 0;
   console.log(chalk.cyan('\nAladdinAI doctor\n'));

package/commands/init.js

@@ -1,3 +1,4 @@
+// NOTICE: This file is protected under RCF-PL
 // `aladdin-ai init` — bootstrap a new AladdinAI deployment.
 //
 // Default path (image-based, what 95% of users want):
@@ -16,23 +17,30 @@ import ora from 'ora';
 import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'path';
+// [RCF:PROTECTED]
 import crypto from 'crypto';
 import { fileURLToPath } from 'node:url';
 import { runPrereqChecks } from '../lib/prereq.js';
 import { compose } from '../lib/compose.js';
+import { runSetupWizard } from './wizard.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = path.resolve(__dirname, '..', 'templates');
 const REPO_URL = 'https://github.com/aliyevaladddin/AladdinAI.git';
 
+// [RCF:PROTECTED]
 function genSecret(bytes = 32) {
+// [RCF:PROTECTED]
   return crypto.randomBytes(bytes).toString('hex');
 }
 
+// [RCF:PROTECTED]
 function genFernetKey() {
+// [RCF:PROTECTED]
   return crypto.randomBytes(32).toString('base64url') + '=';
 }
 
+// [RCF:PROTECTED]
 function fillEnv(text, vars) {
   let out = text;
   for (const [k, v] of Object.entries(vars)) {
@@ -41,6 +49,7 @@ function fillEnv(text, vars) {
   return out;
 }
 
+// [RCF:PROTECTED]
 async function writeEnv(targetDir) {
   // Note: file is named `env.template` (no leading dot) because npm's default
   // packaging silently drops dotfiles from `files` globs.
@@ -55,6 +64,7 @@ async function writeEnv(targetDir) {
 }
 
 // ── Image-based install (default) ─────────────────────────────────────
+// [RCF:PROTECTED]
 async function installFromImages(targetDir, { start }) {
   await fs.ensureDir(targetDir);
 
@@ -102,6 +112,7 @@ async function installFromImages(targetDir, { start }) {
 }
 
 // ── Source-based install (--source flag, for contributors) ────────────
+// [RCF:PROTECTED]
 async function installFromSource(targetDir, { start }) {
   const cloneSpin = ora('Cloning repository').start();
   try {
@@ -143,6 +154,7 @@ async function installFromSource(targetDir, { start }) {
 }
 
 // ── Entry point ───────────────────────────────────────────────────────
+// [RCF:PROTECTED]
 export async function initCommand(opts) {
   console.log(chalk.cyan('\nAladdinAI'));
   console.log(chalk.dim('Self-hosted AI workspace — agents, memory, CRM, channels.\n'));
@@ -195,6 +207,9 @@ export async function initCommand(opts) {
     console.log(chalk.green('\n✓ Services running'));
     console.log('\n  Frontend: ' + chalk.cyan('http://localhost:3000'));
     console.log('  Backend:  ' + chalk.cyan('http://localhost:8000'));
+
+    // Run setup wizard after successful start
+    await runSetupWizard(targetDir);
   } else {
     console.log(chalk.green('\nSetup complete (services not started).'));
     console.log(`\n  cd ${answers.projectName}`);

package/commands/lifecycle.js

@@ -1,8 +1,10 @@
+// NOTICE: This file is protected under RCF-PL
 // `aladdin-ai up | down | restart | logs` — docker compose wrappers.
 
 import chalk from 'chalk';
 import { compose } from '../lib/compose.js';
 
+// [RCF:PROTECTED]
 export async function upCommand(opts) {
   console.log(chalk.cyan('Starting AladdinAI services…\n'));
   const args = ['up', '-d'];
@@ -14,6 +16,7 @@ export async function upCommand(opts) {
   console.log('  Backend:  ' + chalk.cyan('http://localhost:8000/api/docs'));
 }
 
+// [RCF:PROTECTED]
 export async function downCommand(opts) {
   console.log(chalk.cyan('Stopping AladdinAI services…\n'));
   const args = ['down'];
@@ -22,6 +25,7 @@ export async function downCommand(opts) {
   process.exit(r.exitCode || 0);
 }
 
+// [RCF:PROTECTED]
 export async function restartCommand(service) {
   console.log(chalk.cyan(`Restarting ${service || 'all services'}…\n`));
   const args = ['restart'];
@@ -30,6 +34,7 @@ export async function restartCommand(service) {
   process.exit(r.exitCode || 0);
 }
 
+// [RCF:PROTECTED]
 export async function logsCommand(service, opts) {
   const args = ['logs'];
   if (opts.follow) args.push('-f');
@@ -39,6 +44,7 @@ export async function logsCommand(service, opts) {
   process.exit(r.exitCode || 0);
 }
 
+// [RCF:PROTECTED]
 export async function updateCommand() {
   console.log(chalk.cyan('Pulling latest images…\n'));
   let r = await compose(['pull']);

package/commands/wizard.js

@@ -0,0 +1,308 @@
+// NOTICE: This file is protected under RCF-PL
+// Setup wizard — runs after first install to configure LLM providers and create first agent
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { execa } from 'execa';
+
+const PROVIDER_CONFIGS = {
+  nim: {
+    name: 'NVIDIA NIM',
+    description: 'Free tier available, best performance',
+    baseUrl: 'https://integrate.api.nvidia.com/v1',
+    env: {
+      NIM_API_KEY: 'Get from: https://build.nvidia.com',
+      NIM_BASE_URL: 'https://integrate.api.nvidia.com/v1',
+      NIM_MODEL: 'meta/llama-3.1-70b-instruct',
+    },
+  },
+  openai: {
+    name: 'OpenAI',
+    description: 'GPT-4, GPT-3.5 Turbo',
+    baseUrl: 'https://api.openai.com/v1',
+    env: {
+      OPENAI_API_KEY: 'Get from: https://platform.openai.com/api-keys',
+    },
+  },
+  anthropic: {
+    name: 'Anthropic',
+    description: 'Claude 3.5 Sonnet, Opus, Haiku',
+    baseUrl: 'https://api.anthropic.com',
+    env: {
+      ANTHROPIC_API_KEY: 'Get from: https://console.anthropic.com/settings/keys',
+    },
+  },
+  local: {
+    name: 'Local (BentoML)',
+    description: 'Self-hosted models',
+    baseUrl: 'http://localhost:3000',
+    env: {},
+  },
+};
+
+// [RCF:PROTECTED]
+async function setupProviders() {
+  console.log(chalk.cyan('\n📡 LLM Provider Setup\n'));
+  console.log(chalk.dim('Select which LLM providers you want to configure.\n'));
+
+  const { providers } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'providers',
+      message: 'Select providers (Space to select, Enter to continue):',
+      choices: [
+        {
+          name: `${chalk.green('●')} NVIDIA NIM (Recommended) - Free tier, 70B+ models`,
+          value: 'nim',
+          checked: true,
+        },
+        {
+          name: `  OpenAI - GPT-4, GPT-3.5 Turbo`,
+          value: 'openai',
+        },
+        {
+          name: `  Anthropic - Claude 3.5 Sonnet, Opus`,
+          value: 'anthropic',
+        },
+        {
+          name: `  Local (BentoML) - Self-hosted models`,
+          value: 'local',
+        },
+      ],
+    },
+  ]);
+
+  if (providers.length === 0) {
+    console.log(chalk.yellow('\n⚠ No providers selected. You can configure them later in Settings.\n'));
+    return {};
+  }
+
+  const envUpdates = {};
+
+  for (const provider of providers) {
+    const config = PROVIDER_CONFIGS[provider];
+    console.log(chalk.cyan(`\n── ${config.name} ──`));
+
+    if (Object.keys(config.env).length > 0) {
+      const { shouldConfigure } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'shouldConfigure',
+          message: `Configure ${config.name} now?`,
+          default: true,
+        },
+      ]);
+
+      if (shouldConfigure) {
+        for (const [key, hint] of Object.entries(config.env)) {
+          const isSecret = key.toLowerCase().includes('key') || key.toLowerCase().includes('secret') || key.toLowerCase().includes('password') || key.toLowerCase().includes('token');
+          const { value } = await inquirer.prompt([
+            {
+              type: isSecret ? 'password' : 'input',
+              name: 'value',
+              message: `${key}:`,
+              mask: isSecret ? '*' : undefined,
+              validate: (input) => input.length > 0 || 'Required',
+            },
+          ]);
+          envUpdates[key] = value;
+        }
+      } else {
+        console.log(chalk.dim(`  ${hint}`));
+      }
+    } else {
+      console.log(chalk.dim('  No configuration needed - will use local endpoint'));
+    }
+  }
+
+  return envUpdates;
+}
+
+// [RCF:PROTECTED]
+async function setupMongoDB() {
+  console.log(chalk.cyan('\n🗄️  MongoDB Atlas Setup\n'));
+  console.log(chalk.dim('MongoDB Atlas is used for vector memory and media storage.\n'));
+
+  const { useMongoDB } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'useMongoDB',
+      message: 'Configure MongoDB Atlas now?',
+      default: true,
+    },
+  ]);
+
+  if (!useMongoDB) {
+    console.log(chalk.yellow('⚠ Skipping MongoDB - memory features will be disabled'));
+    console.log(chalk.dim('  Get free $500 credits: https://www.mongodb.com/startups\n'));
+    return {};
+  }
+
+  console.log(chalk.dim('\nGet connection string from:'));
+  console.log(chalk.dim('1. https://cloud.mongodb.com'));
+  console.log(chalk.dim('2. Connect → Drivers → Connection string\n'));
+
+  const { mongoUrl } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'mongoUrl',
+      message: 'MongoDB connection string:',
+      default: 'mongodb+srv://user:pass@cluster.mongodb.net/',
+      validate: (input) =>
+        input.startsWith('mongodb://') || input.startsWith('mongodb+srv://') || 'Must be a valid MongoDB URL',
+    },
+  ]);
+
+  return { MONGODB_URL: mongoUrl };
+}
+
+// [RCF:PROTECTED]
+async function createFirstAgent() {
+  console.log(chalk.cyan('\n🤖 Create Your First Agent\n'));
+
+  const { shouldCreate } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldCreate',
+      message: 'Create a starter agent now?',
+      default: true,
+    },
+  ]);
+
+  if (!shouldCreate) {
+    console.log(chalk.dim('  You can create agents later from the dashboard\n'));
+    return;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Choose agent template:',
+      choices: [
+        {
+          name: '💬 General Assistant - Helpful chatbot for general tasks',
+          value: 'general',
+        },
+        {
+          name: '📊 CRM Assistant - Sales and contact management',
+          value: 'crm',
+        },
+        {
+          name: '📧 Email Assistant - Email drafting and responses',
+          value: 'email',
+        },
+        {
+          name: '🔍 Research Assistant - Web search and analysis',
+          value: 'research',
+        },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Agent name (lowercase, no spaces):',
+      default: (answers) => answers.template + '_agent',
+      validate: (input) => /^[a-z0-9_]+$/.test(input) || 'Only lowercase letters, numbers, and underscores',
+    },
+  ]);
+
+  const templates = {
+    general: {
+      display_name: 'General Assistant',
+      system_prompt: 'You are a helpful AI assistant. Answer questions clearly and concisely.',
+      tools: [],
+    },
+    crm: {
+      display_name: 'CRM Assistant',
+      system_prompt:
+        'You are a CRM assistant. Help manage contacts, deals, and activities. Always search the CRM before creating new records.',
+      tools: ['search_contacts', 'create_contact', 'create_deal', 'add_activity'],
+    },
+    email: {
+      display_name: 'Email Assistant',
+      system_prompt: 'You are an email assistant. Draft professional emails and help with correspondence.',
+      tools: ['send_email', 'search_contacts'],
+    },
+    research: {
+      display_name: 'Research Assistant',
+      system_prompt: 'You are a research assistant. Search for information and provide detailed analysis.',
+      tools: ['web_search', 'analyze_image'],
+    },
+  };
+
+  const agentConfig = {
+    name: answers.name,
+    ...templates[answers.template],
+    model: 'meta/llama-3.1-70b-instruct',
+    memory_enabled: true,
+  };
+
+  console.log(chalk.dim(`\n  Agent will be created after services start\n`));
+
+  return agentConfig;
+}
+
+// [RCF:PROTECTED]
+export async function runSetupWizard(targetDir) {
+  console.log(chalk.bold.cyan('\n✨ AladdinAI Setup Wizard\n'));
+  console.log(chalk.dim('Configure your AI workspace in a few steps.\n'));
+
+  const { shouldRun } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldRun',
+      message: 'Run setup wizard?',
+      default: true,
+    },
+  ]);
+
+  if (!shouldRun) {
+    console.log(chalk.dim('  You can configure everything later from the dashboard\n'));
+    return;
+  }
+
+  // Step 1: Providers
+  const providerEnv = await setupProviders();
+
+  // Step 2: MongoDB
+  const mongoEnv = await setupMongoDB();
+
+  // Step 3: First agent
+  const agentConfig = await createFirstAgent();
+
+  // Update .env file
+  if (Object.keys({ ...providerEnv, ...mongoEnv }).length > 0) {
+    const spinner = ora('Updating .env with your configuration').start();
+    try {
+      const fs = await import('fs-extra');
+      const path = await import('path');
+      const envPath = path.join(targetDir, '.env');
+      let envContent = await fs.readFile(envPath, 'utf8');
+
+      for (const [key, value] of Object.entries({ ...providerEnv, ...mongoEnv })) {
+        const regex = new RegExp(`^${key}=.*$`, 'm');
+        if (regex.test(envContent)) {
+          envContent = envContent.replace(regex, `${key}=${value}`);
+        } else {
+          envContent += `\n${key}=${value}`;
+        }
+      }
+
+      await fs.writeFile(envPath, envContent);
+      spinner.succeed('Configuration saved to .env');
+    } catch (err) {
+      spinner.fail('Failed to update .env');
+      console.error(chalk.red(err.message));
+    }
+  }
+
+  // Save agent config for post-startup
+  if (agentConfig) {
+    const fs = await import('fs-extra');
+    const path = await import('path');
+    await fs.writeJson(path.join(targetDir, '.aladdin-setup.json'), { agentConfig }, { spaces: 2 });
+  }
+
+  console.log(chalk.green('\n✓ Setup wizard complete!\n'));
+}

package/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// NOTICE: This file is protected under RCF-PL
 
 import { Command } from 'commander';
 import { readFileSync } from 'node:fs';
@@ -14,6 +15,7 @@ import {
   updateCommand,
 } from './commands/lifecycle.js';
 import { doctorCommand } from './commands/doctor.js';
+import { runSetupWizard } from './commands/wizard.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
@@ -74,6 +76,14 @@ program
   .description('Diagnose setup issues: docker, .env, ports, services')
   .action(doctorCommand);
 
+program
+  .command('setup')
+  .description('Run configuration wizard to set up providers and agents')
+  .action(async () => {
+    const cwd = process.cwd();
+    await runSetupWizard(cwd);
+  });
+
 program.parseAsync(process.argv).catch((err) => {
   console.error(err.shortMessage || err.message);
   process.exit(1);

package/lib/compose.js

@@ -1,3 +1,4 @@
+// NOTICE: This file is protected under RCF-PL
 // Thin wrapper for invoking `docker compose` from any subcommand.
 
 import { execa } from 'execa';
@@ -5,6 +6,7 @@ import { checkDocker } from './prereq.js';
 import { requireProjectRoot } from './project.js';
 import chalk from 'chalk';
 
+// [RCF:PROTECTED]
 export async function compose(args, { cwd, stdio = 'inherit' } = {}) {
   const root = cwd || requireProjectRoot();
   const docker = await checkDocker();

package/lib/prereq.js

@@ -1,8 +1,10 @@
+// NOTICE: This file is protected under RCF-PL
 // Check for required tools on the user's machine.
 
 import { execa } from 'execa';
 import chalk from 'chalk';
 
+// [RCF:PROTECTED]
 async function has(cmd, args = ['--version']) {
   try {
     const r = await execa(cmd, args, { reject: false });
@@ -12,6 +14,7 @@ async function has(cmd, args = ['--version']) {
   }
 }
 
+// [RCF:PROTECTED]
 export async function checkDocker() {
   if (!(await has('docker'))) {
     return { ok: false, message: 'Docker not found. Install: https://docs.docker.com/get-docker/' };
@@ -30,6 +33,7 @@ export async function checkDocker() {
   return { ok: true, composeCmd: v2 ? ['docker', ['compose']] : ['docker-compose', []] };
 }
 
+// [RCF:PROTECTED]
 export async function checkGit() {
   if (!(await has('git'))) {
     return { ok: false, message: 'git not found. Install: https://git-scm.com/downloads' };
@@ -37,6 +41,7 @@ export async function checkGit() {
   return { ok: true };
 }
 
+// [RCF:PROTECTED]
 export async function runPrereqChecks({ requireGit = false } = {}) {
   const docker = await checkDocker();
   if (!docker.ok) {

package/lib/project.js

@@ -1,3 +1,4 @@
+// NOTICE: This file is protected under RCF-PL
 // Locate the AladdinAI project root from the current working directory.
 //
 // Strategy: walk up from cwd looking for docker-compose.yml AND backend/ dir.
@@ -6,6 +7,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 
+// [RCF:PROTECTED]
 export function findProjectRoot(start = process.cwd()) {
   let dir = path.resolve(start);
   const { root } = path.parse(dir);
@@ -18,6 +20,7 @@ export function findProjectRoot(start = process.cwd()) {
   }
 }
 
+// [RCF:PROTECTED]
 export function requireProjectRoot() {
   const root = findProjectRoot();
   if (!root) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aladdin-ai",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "Self-hosted AI workspace — agents, memory, CRM, channels. One command to install and run.",
   "main": "index.js",
   "bin": {