aladdin-ai 1.2.0 → 2.0.0

package/README.md

@@ -1,25 +1,140 @@
-# 🪄 AladdinAI CLI Installer
+# aladdin-ai
 
-The official bootstrap tool for the **AladdinAI Platform**. 
+Self-hosted AI workspace, one command to install and run.
 
-This tool allows you to deploy the full AladdinAI ecosystem, including the AI Orchestrator, CRM integration, and the Desktop Application, with a single command.
+```bash
+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
+finishes.
+
+No `git`, no source code on your machine, no Python or Node toolchain.
+Just Docker.
+
+## Install modes
 
-## 🚀 Installation
- 
-You don't need to install this package globally. Just run:
+| Mode | Command | What you get | Who it's for |
+|---|---|---|---|
+| Image (default) | `npx aladdin-ai` | compose + `.env` (~2 files), images pulled from GHCR | Anyone who just wants to use AladdinAI |
+| Source | `npx aladdin-ai init --source` | Full git clone, images built locally | Contributors who want to modify the code |
+
+Updates in image mode are one command: `npx aladdin-ai update`.
+
+## Commands
 
 ```bash
-npx aladdin-ai
+npx aladdin-ai                  # alias for `init` (image mode)
+npx aladdin-ai init             # bootstrap a new project here
+npx aladdin-ai init --source    # bootstrap from git clone (for contributors)
+
+npx aladdin-ai up               # start services (docker compose up -d)
+npx aladdin-ai up --build       # rebuild images first (source mode)
+npx aladdin-ai down             # stop services
+npx aladdin-ai down -v          # also wipe volumes (DESTROYS data)
+npx aladdin-ai restart          # restart everything
+npx aladdin-ai restart backend  # restart one service
+
+npx aladdin-ai logs             # tail all service logs
+npx aladdin-ai logs backend -f  # follow one service
+
+npx aladdin-ai update           # pull latest images and recreate services
+npx aladdin-ai doctor           # diagnose setup issues
+```
+
+All commands except `init` find the nearest `docker-compose.yml` above
+the current working directory, so you can run them from anywhere inside
+a project.
+
+## `doctor`
+
+Quick health check when something feels off:
+
+```
+$ npx aladdin-ai doctor
+
+Tooling
+  ✓ git installed
+  ✓ docker + compose available, daemon running
+
+Project
+  ✓ project root: /home/me/aladdin-ai
+  ✓ .env has required keys
+
+Ports
+  ✓ port 3000 (frontend) listening
+  ✓ port 8000 (backend) listening
+  ✓ port 5432 (postgres) listening
+
+Services
+  ✓ backend: running
+  ✓ frontend: running
+  ✓ postgres: running
+
+Reachability
+  ✓ backend responding on http://localhost:8000 (HTTP 200)
+  ✓ frontend responding on http://localhost:3000 (HTTP 200)
+
+All critical checks passed.
+```
+
+It also flags `.env` files that still hold the example placeholders, so
+you don't accidentally expose an instance with `JWT_SECRET=change-me`.
+
+## Pinning to a specific version
+
+By default the compose file pulls the `:latest` tag. To pin a release,
+set `ALADDINAI_VERSION` in your `.env`:
+
+```
+ALADDINAI_VERSION=1.0.0
+```
+
+Then `npx aladdin-ai update` will only ever pull that version.
+
+## Requirements
+
+- Node.js 18+
+- Docker 20+ with the Compose plugin (`docker compose version` works)
+- `git` — only for `init --source`
+
+## What is AladdinAI?
+
+A self-hosted AI workspace: agents with private + shared memory, CRM,
+multi-channel messaging (Telegram / WhatsApp / SMS / email), cron
+triggers, and provider-agnostic LLM routing. See the
+[main repo](https://github.com/aliyevaladddin/AladdinAI) for the full
+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
+```
+
+**Backend + frontend images** — publish to GHCR via
+`.github/workflows/docker-publish.yml`:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
 ```
 
-## ✨ What's included?
-- **AI Orchestrator**: Support for MiniCPM3 and other LLMs.
-- **RCF Protocol**: Built-in security and correlation framework.
-- **Desktop App**: Native installers for Mac, Windows, and Linux.
-- **Full CRM**: Complete deals and contacts management system.
+The workflow builds both images for linux/amd64 + linux/arm64 and pushes
+them as `ghcr.io/aliyevaladddin/aladdinai-backend:1.0.0`,
+`ghcr.io/aliyevaladddin/aladdinai-frontend:1.0.0`, and `:latest`.
 
-## 🛡️ Security
-Protected by the **Restricted Correlation Framework (RCF v2.0.3)**.
+## License
 
----
-Developed by [Aladdin Aliyev](https://github.com/aliyevaladddin)
+Apache-2.0

package/commands/doctor.js

@@ -0,0 +1,172 @@
+// `aladdin-ai doctor` — diagnose common setup issues.
+
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import net from 'node:net';
+import path from 'path';
+import { execa } from 'execa';
+import { findProjectRoot } from '../lib/project.js';
+import { checkDocker, checkGit } from '../lib/prereq.js';
+
+const ok = (msg) => console.log(chalk.green('  ✓ ') + msg);
+const bad = (msg, hint) => {
+  console.log(chalk.red('  ✗ ') + msg);
+  if (hint) console.log(chalk.dim('    → ' + hint));
+};
+const warn = (msg, hint) => {
+  console.log(chalk.yellow('  ! ') + msg);
+  if (hint) console.log(chalk.dim('    → ' + 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.
+async function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const sock = new net.Socket();
+    const done = (val) => { sock.destroy(); resolve(val); };
+    sock.setTimeout(500);
+    sock.once('connect', () => done(true));
+    sock.once('timeout', () => done(false));
+    sock.once('error', () => done(false));
+    sock.connect(port, '127.0.0.1');
+  });
+}
+
+async function fetchWithTimeout(url, ms = 3000) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), ms);
+  try {
+    const r = await fetch(url, { signal: ctl.signal });
+    return r;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export async function doctorCommand() {
+  let failures = 0;
+  console.log(chalk.cyan('\nAladdinAI doctor\n'));
+
+  // ── Tooling ──────────────────────────────────────────────────────
+  console.log(chalk.bold('Tooling'));
+  const git = await checkGit();
+  git.ok ? ok('git installed') : (bad('git missing', 'install: https://git-scm.com/downloads'), failures++);
+
+  const docker = await checkDocker();
+  if (docker.ok) {
+    ok('docker + compose available, daemon running');
+  } else {
+    bad('docker not ready', docker.message);
+    failures++;
+    // Without docker we can't go further on services
+    console.log(chalk.red('\nFix Docker first; re-run `npx aladdin-ai doctor`.'));
+    process.exit(1);
+  }
+
+  // ── Project ──────────────────────────────────────────────────────
+  console.log(chalk.bold('\nProject'));
+  const root = findProjectRoot();
+  if (!root) {
+    warn('not inside an AladdinAI project',
+      'run `npx aladdin-ai init` or cd into the project directory');
+    console.log(chalk.dim('\nSkipping project-level checks.\n'));
+    process.exit(failures > 0 ? 1 : 0);
+  }
+  ok(`project root: ${root}`);
+
+  const envPath = path.join(root, '.env');
+  if (!fs.existsSync(envPath)) {
+    bad('.env missing', 'copy .env.example to .env and fill in secrets');
+    failures++;
+  } else {
+    const env = await fs.readFile(envPath, 'utf8');
+    const need = ['JWT_SECRET', 'FERNET_KEY', 'POSTGRES_PASSWORD'];
+    const placeholders = [
+      ['JWT_SECRET', 'change-me-in-production'],
+      ['POSTGRES_PASSWORD', 'replace_with_secure_password'],
+      ['FERNET_KEY', 'your-secret-fernet-key-here'],
+    ];
+    let envOk = true;
+    for (const k of need) {
+      if (!new RegExp(`^${k}=\\S`, 'm').test(env)) {
+        bad(`.env missing ${k}`);
+        envOk = false;
+        failures++;
+      }
+    }
+    for (const [k, bad_val] of placeholders) {
+      if (new RegExp(`^${k}=${bad_val.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\s*$`, 'm').test(env)) {
+        warn(`.env: ${k} still uses the default placeholder`,
+          'generate a real value before exposing this instance');
+      }
+    }
+    if (envOk) ok('.env has required keys');
+  }
+
+  // ── Ports ────────────────────────────────────────────────────────
+  console.log(chalk.bold('\nPorts'));
+  for (const [port, label] of [[3000, 'frontend'], [8000, 'backend'], [5432, 'postgres']]) {
+    const inUse = await isPortInUse(port);
+    if (inUse) {
+      ok(`port ${port} (${label}) listening`);
+    } else {
+      warn(`port ${port} (${label}) nothing listening`,
+        'service may not be running — try `npx aladdin-ai up`');
+    }
+  }
+
+  // ── Compose services ─────────────────────────────────────────────
+  console.log(chalk.bold('\nServices'));
+  const [bin, prefix] = docker.composeCmd;
+  const psRes = await execa(bin, [...prefix, 'ps', '--format', 'json'], {
+    cwd: root,
+    reject: false,
+  });
+  if (psRes.exitCode !== 0) {
+    bad('docker compose ps failed', psRes.stderr?.slice(0, 200));
+    failures++;
+  } else {
+    const lines = psRes.stdout.split('\n').filter(Boolean);
+    if (lines.length === 0) {
+      warn('no compose services running', 'run `npx aladdin-ai up`');
+    } else {
+      for (const line of lines) {
+        try {
+          const svc = JSON.parse(line);
+          const name = svc.Service || svc.Name;
+          const state = svc.State || svc.Status;
+          if (state === 'running' || /Up/.test(state || '')) ok(`${name}: ${state}`);
+          else { bad(`${name}: ${state}`); failures++; }
+        } catch {
+          // ignore malformed line
+        }
+      }
+    }
+  }
+
+  // ── HTTP reachability ────────────────────────────────────────────
+  console.log(chalk.bold('\nReachability'));
+  const beRes = await fetchWithTimeout('http://localhost:8000/');
+  if (beRes && beRes.status < 500) ok(`backend responding on http://localhost:8000 (HTTP ${beRes.status})`);
+  else { warn('backend not responding on :8000', 'check `npx aladdin-ai logs backend`'); }
+
+  const feRes = await fetchWithTimeout('http://localhost:3000');
+  if (feRes && feRes.status < 500) {
+    ok(`frontend responding on http://localhost:3000 (HTTP ${feRes.status})`);
+  } else {
+    warn('frontend not responding on :3000', 'check `npx aladdin-ai logs frontend`');
+  }
+
+  // ── Summary ──────────────────────────────────────────────────────
+  console.log();
+  if (failures === 0) {
+    console.log(chalk.green('All critical checks passed.\n'));
+    process.exit(0);
+  } else {
+    console.log(chalk.red(`${failures} issue${failures === 1 ? '' : 's'} found.\n`));
+    process.exit(1);
+  }
+}

package/commands/init.js

@@ -0,0 +1,208 @@
+// `aladdin-ai init` — bootstrap a new AladdinAI deployment.
+//
+// Default path (image-based, what 95% of users want):
+//   1. Create target dir
+//   2. Copy bundled docker-compose.yml + .env template
+//   3. Fill .env with secure random secrets
+//   4. `docker compose pull` + `docker compose up -d`
+//   No git, no source code on the user's machine. Updates via `docker pull`.
+//
+// Source path (--source flag, for contributors):
+//   git clone the repo + build images locally with docker-compose.dev.yml.
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'node:url';
+import { runPrereqChecks } from '../lib/prereq.js';
+import { compose } from '../lib/compose.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';
+
+function genSecret(bytes = 32) {
+  return crypto.randomBytes(bytes).toString('hex');
+}
+
+function genFernetKey() {
+  return crypto.randomBytes(32).toString('base64url') + '=';
+}
+
+function fillEnv(text, vars) {
+  let out = text;
+  for (const [k, v] of Object.entries(vars)) {
+    out = out.replace(new RegExp(`^${k}=__GENERATED__$`, 'm'), `${k}=${v}`);
+  }
+  return out;
+}
+
+async function writeEnv(targetDir) {
+  const tmplPath = path.join(TEMPLATES_DIR, '.env.template');
+  const tmpl = await fs.readFile(tmplPath, 'utf8');
+  const filled = fillEnv(tmpl, {
+    POSTGRES_PASSWORD: genSecret(16),
+    JWT_SECRET: genSecret(32),
+    FERNET_KEY: genFernetKey(),
+  });
+  await fs.writeFile(path.join(targetDir, '.env'), filled);
+}
+
+// ── Image-based install (default) ─────────────────────────────────────
+async function installFromImages(targetDir, { start }) {
+  await fs.ensureDir(targetDir);
+
+  // 1. Copy compose template
+  const composeSpin = ora('Writing docker-compose.yml').start();
+  try {
+    await fs.copy(
+      path.join(TEMPLATES_DIR, 'docker-compose.yml'),
+      path.join(targetDir, 'docker-compose.yml'),
+    );
+    composeSpin.succeed('docker-compose.yml written');
+  } catch (err) {
+    composeSpin.fail('Failed to write docker-compose.yml');
+    throw err;
+  }
+
+  // 2. Generate .env
+  const envSpin = ora('Generating .env with secure secrets').start();
+  try {
+    await writeEnv(targetDir);
+    envSpin.succeed('.env created');
+  } catch (err) {
+    envSpin.fail('Failed to write .env');
+    throw err;
+  }
+
+  if (!start) return;
+
+  // 3. Pull images
+  console.log(chalk.cyan('\nPulling images from ghcr.io (first run can take a few minutes)…\n'));
+  const pullRes = await compose(['pull'], { cwd: targetDir });
+  if (pullRes.exitCode !== 0) {
+    console.error(chalk.red('\ndocker compose pull failed. Images may not be published yet.'));
+    console.error(chalk.dim('You can build from source instead: npx aladdin-ai init --source\n'));
+    process.exit(1);
+  }
+
+  // 4. Start
+  console.log(chalk.cyan('\nStarting services…\n'));
+  const upRes = await compose(['up', '-d'], { cwd: targetDir });
+  if (upRes.exitCode !== 0) {
+    console.error(chalk.red('\ndocker compose up failed. Inspect logs with `npx aladdin-ai logs`.'));
+    process.exit(1);
+  }
+}
+
+// ── Source-based install (--source flag, for contributors) ────────────
+async function installFromSource(targetDir, { start }) {
+  const cloneSpin = ora('Cloning repository').start();
+  try {
+    await execa('git', ['clone', '--depth', '1', REPO_URL, targetDir]);
+    await fs.remove(path.join(targetDir, '.git'));
+    cloneSpin.succeed('Repository cloned');
+  } catch (err) {
+    cloneSpin.fail('git clone failed');
+    throw err;
+  }
+
+  const envSpin = ora('Generating .env with secure secrets').start();
+  try {
+    const tmpl = await fs.readFile(path.join(targetDir, '.env.example'), 'utf8');
+    const dbPassword = genSecret(16);
+    const filled = tmpl
+      .replace(/^POSTGRES_PASSWORD=.*$/m, `POSTGRES_PASSWORD=${dbPassword}`)
+      .replace(/^JWT_SECRET=.*$/m, `JWT_SECRET=${genSecret(32)}`)
+      .replace(/^FERNET_KEY=.*$/m, `FERNET_KEY=${genFernetKey()}`)
+      .replace(
+        /^# DATABASE_URL=.*$/m,
+        `DATABASE_URL=postgresql+asyncpg://aladdin_user:${dbPassword}@postgres:5432/aladdinai`,
+      );
+    await fs.writeFile(path.join(targetDir, '.env'), filled);
+    envSpin.succeed('.env created');
+  } catch (err) {
+    envSpin.fail('Failed to create .env');
+    throw err;
+  }
+
+  if (!start) return;
+
+  console.log(chalk.cyan('\nBuilding images locally and starting…\n'));
+  const r = await compose(['up', '-d', '--build'], { cwd: targetDir });
+  if (r.exitCode !== 0) {
+    console.error(chalk.red('\ndocker compose up failed. Inspect logs with `npx aladdin-ai logs`.'));
+    process.exit(1);
+  }
+}
+
+// ── Entry point ───────────────────────────────────────────────────────
+export async function initCommand(opts) {
+  console.log(chalk.cyan('\nAladdinAI'));
+  console.log(chalk.dim('Self-hosted AI workspace — agents, memory, CRM, channels.\n'));
+
+  // Source mode needs git as well; image mode only needs docker.
+  await runPrereqChecks({ requireGit: !!opts.source });
+
+  const defaults = {
+    projectName: opts.name || 'aladdin-ai',
+    start: !opts.skipStart,
+  };
+
+  const answers = opts.yes
+    ? defaults
+    : await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectName',
+          message: 'Project directory:',
+          default: defaults.projectName,
+        },
+        {
+          type: 'confirm',
+          name: 'start',
+          message: opts.source
+            ? 'Build images and start services after setup?'
+            : 'Pull images and start services after setup?',
+          default: defaults.start,
+        },
+      ]);
+
+  const targetDir = path.resolve(process.cwd(), answers.projectName);
+  if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+    console.log(chalk.red(`\nDirectory "${answers.projectName}" already exists and is not empty.`));
+    process.exit(1);
+  }
+
+  try {
+    if (opts.source) {
+      await installFromSource(targetDir, answers);
+    } else {
+      await installFromImages(targetDir, answers);
+    }
+  } catch (err) {
+    console.error(chalk.red('\n' + (err.shortMessage || err.message)));
+    process.exit(1);
+  }
+
+  if (answers.start) {
+    console.log(chalk.green('\n✓ Services running'));
+    console.log('\n  Frontend: ' + chalk.cyan('http://localhost:3000'));
+    console.log('  Backend:  ' + chalk.cyan('http://localhost:8000'));
+  } else {
+    console.log(chalk.green('\nSetup complete (services not started).'));
+    console.log(`\n  cd ${answers.projectName}`);
+    console.log('  npx aladdin-ai up');
+  }
+
+  console.log(chalk.dim('\nHealth check: npx aladdin-ai doctor'));
+  if (!opts.source) {
+    console.log(chalk.dim('Update: cd ' + answers.projectName + ' && docker compose pull && npx aladdin-ai restart\n'));
+  } else {
+    console.log(chalk.dim('Source tree is in ' + answers.projectName + ' — edit and rebuild with `npx aladdin-ai up --build`\n'));
+  }
+}

package/commands/lifecycle.js

@@ -0,0 +1,50 @@
+// `aladdin-ai up | down | restart | logs` — docker compose wrappers.
+
+import chalk from 'chalk';
+import { compose } from '../lib/compose.js';
+
+export async function upCommand(opts) {
+  console.log(chalk.cyan('Starting AladdinAI services…\n'));
+  const args = ['up', '-d'];
+  if (opts.build) args.push('--build');
+  const r = await compose(args);
+  if (r.exitCode !== 0) process.exit(r.exitCode || 1);
+  console.log(chalk.green('\n✓ Services started'));
+  console.log('  Frontend: ' + chalk.cyan('http://localhost:3000'));
+  console.log('  Backend:  ' + chalk.cyan('http://localhost:8000/api/docs'));
+}
+
+export async function downCommand(opts) {
+  console.log(chalk.cyan('Stopping AladdinAI services…\n'));
+  const args = ['down'];
+  if (opts.volumes) args.push('-v');
+  const r = await compose(args);
+  process.exit(r.exitCode || 0);
+}
+
+export async function restartCommand(service) {
+  console.log(chalk.cyan(`Restarting ${service || 'all services'}…\n`));
+  const args = ['restart'];
+  if (service) args.push(service);
+  const r = await compose(args);
+  process.exit(r.exitCode || 0);
+}
+
+export async function logsCommand(service, opts) {
+  const args = ['logs'];
+  if (opts.follow) args.push('-f');
+  if (opts.tail) args.push('--tail', String(opts.tail));
+  if (service) args.push(service);
+  const r = await compose(args);
+  process.exit(r.exitCode || 0);
+}
+
+export async function updateCommand() {
+  console.log(chalk.cyan('Pulling latest images…\n'));
+  let r = await compose(['pull']);
+  if (r.exitCode !== 0) process.exit(r.exitCode || 1);
+  console.log(chalk.cyan('\nRecreating services with new images…\n'));
+  r = await compose(['up', '-d']);
+  if (r.exitCode !== 0) process.exit(r.exitCode || 1);
+  console.log(chalk.green('\n✓ Updated and running'));
+}

package/index.js

@@ -1,146 +1,80 @@
 #!/usr/bin/env node
 
-// NOTICE: This file is protected under RCF-PL v1.2.8
-// [RCF:PROTECTED]
-
 import { Command } from 'commander';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora from 'ora';
-import { execa } from 'execa';
-import fs from 'fs-extra';
-import path from 'path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import updateNotifier from 'update-notifier';
+import { initCommand } from './commands/init.js';
+import {
+  upCommand,
+  downCommand,
+  restartCommand,
+  logsCommand,
+  updateCommand,
+} from './commands/lifecycle.js';
+import { doctorCommand } from './commands/doctor.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+
+// Check for updates once per day, show a banner on next run
+updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 * 24 }).notify({ defer: false });
 
 const program = new Command();
 
-const REPO_URL = 'https://github.com/aliyevaladddin/AladdinAI.git';
-
-console.log(chalk.cyan(`
-   ╔══════════════════════════════════════════════════════════╗
-   ║                                                          ║
-   ║   ✨  WELCOME TO ALADDIN AI PLATFORM INITIALIZER  ✨   ║
-   ║        Powered by RCF Protocol v2.0.3                    ║
-   ║                                                          ║
-   ╚══════════════════════════════════════════════════════════╝
-`));
-
 program
   .name('aladdin-ai')
-  .description('Bootstrap your own AladdinAI instance')
-  .version('1.2.0')
-  .action(async () => {
-    const { mode } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'mode',
-        message: 'What would you like to do?',
-        choices: [
-          { name: '🚀 Install Desktop App (Recommended)', value: 'desktop' },
-          { name: '💻 Clone Source Code (For Developers)', value: 'source' }
-        ]
-      }
-    ]);
-
-    if (mode === 'desktop') {
-      const spinner = ora('Preparing Desktop App download...').start();
-      try {
-        const platform = process.platform;
-        let downloadUrl = '';
-        let fileName = '';
-
-        // GitHub Release assets usually follow this pattern
-        if (platform === 'darwin') {
-          downloadUrl = 'https://github.com/aliyevaladddin/AladdinAI/releases/latest/download/AladdinAI.dmg';
-          fileName = 'AladdinAI.dmg';
-        } else if (platform === 'win32') {
-          // Changed to match electron-builder default naming or redirect
-          downloadUrl = 'https://github.com/aliyevaladddin/AladdinAI/releases/latest/download/AladdinAI.exe';
-          fileName = 'AladdinAI.exe';
-        } else if (platform === 'linux') {
-          downloadUrl = 'https://github.com/aliyevaladddin/AladdinAI/releases/latest/download/AladdinAI.AppImage';
-          fileName = 'AladdinAI.AppImage';
-        } else {
-          spinner.fail(chalk.red('Platform not supported for desktop direct install.'));
-          return;
-        }
-
-        spinner.text = `Downloading ${fileName} for ${platform}...`;
-        const downloadPath = path.join(process.cwd(), fileName);
-
-        // Use -f to fail on 404, -L to follow redirects
-        try {
-          await execa('curl', ['-f', '-L', '-o', downloadPath, downloadUrl]);
-        } catch (downloadErr) {
-          spinner.fail(chalk.red(`\n❌ Failed to download ${fileName}. Possibly the version is not yet available on GitHub Releases.`));
-          console.log(chalk.yellow(`\nTry downloading manually from: https://github.com/aliyevaladddin/AladdinAI/releases`));
-          return;
-        }
-
-        spinner.succeed(chalk.green(`\n✅ Download complete: ${fileName}`));
-        console.log(chalk.cyan(`\n👉 Opening ${fileName} for installation...`));
-
-        try {
-          if (platform === 'darwin') {
-            await execa('open', [downloadPath]);
-          } else if (platform === 'win32') {
-            // More robust Windows open command using shell
-            await execa('powershell', ['-Command', `Start-Process "${downloadPath}"`], { shell: true });
-          } else {
-            await execa('xdg-open', [downloadPath]);
-          }
-        } catch (openErr) {
-          console.log(chalk.yellow(`\n⚠️  Could not open automatically. Please run ${fileName} manually from this folder.`));
-        }
-
-      } catch (err) {
-        spinner.fail(chalk.red('An unexpected error occurred during installation.'));
-        console.error(err);
-      }
-      return;
-    }
+  .description('Self-hosted AI workspace — agents, memory, CRM, channels.')
+  .version(pkg.version);
 
-    const answers = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'projectName',
-        message: 'What is your project name?',
-        default: 'my-aladdin-ai'
-      },
-      {
-        type: 'confirm',
-        name: 'installDeps',
-        message: 'Would you like to install dependencies automatically?',
-        default: true
-      }
-    ]);
-
-    const targetDir = path.join(process.cwd(), answers.projectName);
-
-    if (fs.existsSync(targetDir)) {
-      console.log(chalk.red(`\n❌ Error: Directory ${answers.projectName} already exists.`));
-      process.exit(1);
-    }
-
-    const spinner = ora('Cloning AladdinAI repository...').start();
+// ── init (default) ────────────────────────────────────────────────────
+program
+  .command('init', { isDefault: true })
+  .description('Set up a new AladdinAI deployment using prebuilt Docker images')
+  .option('-n, --name <name>', 'project directory name')
+  .option('-y, --yes', 'accept defaults, skip prompts')
+  .option('--skip-start', 'do not run docker compose up after setup')
+  .option('--source', 'install from source (git clone + local build, for contributors)')
+  .action(initCommand);
+
+// ── lifecycle ─────────────────────────────────────────────────────────
+program
+  .command('up')
+  .description('Start services (docker compose up -d)')
+  .option('--build', 'rebuild images before starting')
+  .action(upCommand);
 
-    try {
-      await execa('git', ['clone', REPO_URL, targetDir]);
-      spinner.succeed(chalk.green('Repository cloned successfully!'));
-      await fs.remove(path.join(targetDir, '.git'));
+program
+  .command('down')
+  .description('Stop services')
+  .option('-v, --volumes', 'also remove volumes (DESTROYS data)')
+  .action(downCommand);
 
-      if (answers.installDeps) {
-        const feSpinner = ora('Installing Frontend dependencies...').start();
-        await execa('npm', ['install'], { cwd: path.join(targetDir, 'frontend') });
-        feSpinner.succeed(chalk.green('Frontend dependencies installed!'));
-      }
+program
+  .command('restart [service]')
+  .description('Restart all services or a specific one (backend, frontend, postgres)')
+  .action(restartCommand);
 
-      console.log(chalk.blue('\n🛡️  RCF Protocol: Your project is pre-marked for RCF compliance.'));
-      console.log(chalk.green(`\n🚀 Success! Your AladdinAI platform is ready in ${answers.projectName}`));
+program
+  .command('logs [service]')
+  .description('Tail service logs (defaults to all)')
+  .option('-f, --follow', 'follow log output')
+  .option('-t, --tail <lines>', 'number of lines to show from the end', '100')
+  .action(logsCommand);
 
-    } catch (error) {
-      spinner.fail(chalk.red('Failed to bootstrap project.'));
-      console.error(error);
-    }
-  });
+program
+  .command('update')
+  .description('Pull the latest images and recreate services')
+  .action(updateCommand);
 
-program.parse(process.argv);
+// ── diagnostics ───────────────────────────────────────────────────────
+program
+  .command('doctor')
+  .description('Diagnose setup issues: docker, .env, ports, services')
+  .action(doctorCommand);
+
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.shortMessage || err.message);
+  process.exit(1);
+});

package/lib/compose.js

@@ -0,0 +1,17 @@
+// Thin wrapper for invoking `docker compose` from any subcommand.
+
+import { execa } from 'execa';
+import { checkDocker } from './prereq.js';
+import { requireProjectRoot } from './project.js';
+import chalk from 'chalk';
+
+export async function compose(args, { cwd, stdio = 'inherit' } = {}) {
+  const root = cwd || requireProjectRoot();
+  const docker = await checkDocker();
+  if (!docker.ok) {
+    console.error(chalk.red('✗ ') + docker.message);
+    process.exit(1);
+  }
+  const [bin, prefix] = docker.composeCmd;
+  return execa(bin, [...prefix, ...args], { cwd: root, stdio, reject: false });
+}

package/lib/prereq.js

@@ -0,0 +1,54 @@
+// Check for required tools on the user's machine.
+
+import { execa } from 'execa';
+import chalk from 'chalk';
+
+async function has(cmd, args = ['--version']) {
+  try {
+    const r = await execa(cmd, args, { reject: false });
+    return r.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function checkDocker() {
+  if (!(await has('docker'))) {
+    return { ok: false, message: 'Docker not found. Install: https://docs.docker.com/get-docker/' };
+  }
+  // `docker compose` (v2) or legacy `docker-compose`
+  const v2 = await has('docker', ['compose', 'version']);
+  const v1 = await has('docker-compose');
+  if (!v2 && !v1) {
+    return { ok: false, message: 'docker compose plugin not found. Upgrade Docker Desktop to v20+.' };
+  }
+  // Daemon running?
+  const info = await execa('docker', ['info'], { reject: false });
+  if (info.exitCode !== 0) {
+    return { ok: false, message: 'Docker daemon is not running. Start Docker Desktop.' };
+  }
+  return { ok: true, composeCmd: v2 ? ['docker', ['compose']] : ['docker-compose', []] };
+}
+
+export async function checkGit() {
+  if (!(await has('git'))) {
+    return { ok: false, message: 'git not found. Install: https://git-scm.com/downloads' };
+  }
+  return { ok: true };
+}
+
+export async function runPrereqChecks({ requireGit = false } = {}) {
+  const docker = await checkDocker();
+  if (!docker.ok) {
+    console.error(chalk.red('✗ ') + docker.message);
+    process.exit(1);
+  }
+  if (requireGit) {
+    const git = await checkGit();
+    if (!git.ok) {
+      console.error(chalk.red('✗ ') + git.message);
+      process.exit(1);
+    }
+  }
+  return docker; // exposes composeCmd
+}

package/lib/project.js

@@ -0,0 +1,31 @@
+// Locate the AladdinAI project root from the current working directory.
+//
+// Strategy: walk up from cwd looking for docker-compose.yml AND backend/ dir.
+// If not found, return null — caller decides whether to error out.
+
+import fs from 'fs-extra';
+import path from 'path';
+
+export function findProjectRoot(start = process.cwd()) {
+  let dir = path.resolve(start);
+  const { root } = path.parse(dir);
+  while (true) {
+    const compose = path.join(dir, 'docker-compose.yml');
+    const backend = path.join(dir, 'backend');
+    if (fs.existsSync(compose) && fs.existsSync(backend)) return dir;
+    if (dir === root) return null;
+    dir = path.dirname(dir);
+  }
+}
+
+export function requireProjectRoot() {
+  const root = findProjectRoot();
+  if (!root) {
+    console.error(
+      '\nNot inside an AladdinAI project (no docker-compose.yml found above cwd).\n' +
+      'Run `npx aladdin-ai init` first, then cd into the created directory.\n'
+    );
+    process.exit(1);
+  }
+  return root;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aladdin-ai",
-  "version": "1.2.0",
-  "description": "The official CLI for AladdinAI Platform. Powered by RCF Protocol.",
+  "version": "2.0.0",
+  "description": "Self-hosted AI workspace — agents, memory, CRM, channels. One command to install and run.",
   "main": "index.js",
   "bin": {
     "aladdin-ai": "index.js"
@@ -11,16 +11,26 @@
     "registry": "https://registry.npmjs.org/"
   },
   "type": "module",
+  "files": [
+    "index.js",
+    "commands",
+    "lib",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node -e \"import('./index.js')\""
   },
   "keywords": [
     "ai",
-    "orchestrator",
-    "rcf-protocol",
+    "agents",
     "crm",
-    "aladdin-ai",
-    "automation"
+    "fastapi",
+    "nextjs",
+    "self-hosted",
+    "docker",
+    "aladdin-ai"
   ],
   "repository": {
     "type": "git",
@@ -32,12 +42,16 @@
   "homepage": "https://github.com/aliyevaladddin/AladdinAI#readme",
   "author": "Aladdin Aliyev <aladdin@aliyev.site>",
   "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  },
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.0.3",
     "execa": "^9.1.0",
     "fs-extra": "^11.2.0",
     "inquirer": "^9.2.22",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "update-notifier": "^7.0.0"
   }
-}
+}

package/templates/docker-compose.yml

@@ -0,0 +1,53 @@
+# AladdinAI — production compose using prebuilt images from GHCR.
+#
+# Pull updates: docker compose pull
+# Pin a version: set ALADDINAI_VERSION in your .env (defaults to "latest").
+
+services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      POSTGRES_DB: ${POSTGRES_DB}
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    restart: unless-stopped
+
+  backend:
+    image: ghcr.io/aliyevaladddin/aladdinai-backend:${ALADDINAI_VERSION:-latest}
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    environment:
+      # Override to point at the docker-compose Postgres service, not localhost.
+      DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
+    volumes:
+      - media:/app/media
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: unless-stopped
+
+  frontend:
+    image: ghcr.io/aliyevaladddin/aladdinai-frontend:${ALADDINAI_VERSION:-latest}
+    ports:
+      - "3000:3000"
+    env_file:
+      - .env
+    environment:
+      # Server-side Next.js rewrites need to reach backend via the compose network
+      BACKEND_INTERNAL_URL: http://backend:8000
+    depends_on:
+      - backend
+    restart: unless-stopped
+
+volumes:
+  pgdata:
+  media: