@arcadialdev/arcality 2.2.0

package/scripts/init.mjs

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+// scripts/init.mjs — Command: arcality init
+// Single-configuration setup flow:
+//   1. Prompt API key → validate with backend
+//   2. Prompt project name, baseUrl, username, password
+//   3. Detect framework (package.json only, NO .git)
+//   4. Create project via POST /api/v1/projects
+//   5. Write arcality.config
+
+import 'dotenv/config';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+import { intro, outro, text, password as passwordPrompt, spinner, note, isCancel, cancel, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import {
+    configExists,
+    loadProjectConfig,
+    saveProjectConfig,
+    createConfig,
+} from '../src/configManager.mjs';
+import { getApiUrl } from '../src/configLoader.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = process.env.ARCALITY_ROOT || path.resolve(__dirname, '..');
+
+// ── Helpers ──
+
+function getVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+        return pkg.version || 'unknown';
+    } catch {
+        return 'unknown';
+    }
+}
+
+function detectFramework(projectRoot) {
+    try {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) return null;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['next']) return 'Next.js';
+        if (deps['nuxt'] || deps['nuxt3']) return 'Nuxt';
+        if (deps['vite']) return 'Vite';
+        if (deps['react-scripts']) return 'Create React App';
+        if (deps['@angular/core']) return 'Angular';
+        if (deps['vue']) return 'Vue.js';
+        if (deps['svelte'] || deps['@sveltejs/kit']) return 'Svelte';
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+function isValidUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === 'http:' || u.protocol === 'https:';
+    } catch {
+        return false;
+    }
+}
+
+// ── Main ──
+
+async function main() {
+    const version = getVersion();
+    const projectRoot = process.cwd();
+
+    console.clear();
+    const logo = figlet.textSync('Arcality', { font: 'Standard' });
+    intro(chalk.cyanBright(logo));
+
+    note(
+        chalk.magentaBright('Project Initialization') + '\n' +
+        chalk.gray('─'.repeat(50)) + '\n' +
+        chalk.bold.white('📦 Version: ') + chalk.yellow(version) + '\n' +
+        chalk.bold.white('📁 Project: ') + chalk.yellow(projectRoot),
+        'arcality init'
+    );
+
+    // ── Check for existing config ──
+    if (configExists(projectRoot)) {
+        const existing = loadProjectConfig(projectRoot);
+        if (existing) {
+            note(
+                chalk.yellow('⚠️  An arcality.config already exists in this project.') + '\n\n' +
+                chalk.white('  Project: ') + chalk.cyan(existing.project?.name || 'unknown') + '\n' +
+                chalk.white('  Base URL: ') + chalk.cyan(existing.project?.baseUrl || 'unknown') + '\n' +
+                chalk.white('  Project ID: ') + chalk.gray(existing.projectId || 'unknown'),
+                'Existing Configuration'
+            );
+
+            const overwrite = await confirm({
+                message: 'Do you want to reconfigure? This will create a NEW project in backend.',
+            });
+
+            if (isCancel(overwrite) || !overwrite) {
+                outro(chalk.cyan('Configuration unchanged. Use `arcality run` to start.'));
+                return;
+            }
+        }
+    }
+
+    // ── Step 1: API Key ──
+    const apiKey = await text({
+        message: chalk.cyan('🔑 Enter your Arcality API Key:'),
+        placeholder: 'arc_k_live_xxxxx',
+        validate: (v) => {
+            if (!v || !v.trim()) return 'API Key is required.';
+            if (!v.startsWith('arc_k_')) return 'API Key must start with "arc_k_"';
+        },
+    });
+
+    if (isCancel(apiKey)) {
+        cancel('Setup cancelled.');
+        process.exit(0);
+    }
+
+    // ── Step 2: Validate API Key (uses internal API URL) ──
+    const apiUrl = getApiUrl();
+    const s = spinner();
+    s.start('Validating API Key...');
+
+    let organizationId = null;
+
+    try {
+        const res = await fetch(`${apiUrl}/api/v1/auth/validate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey.trim(),
+            },
+        });
+
+        if (!res.ok) {
+            const errorMap = {
+                401: '❌ Invalid API Key. Please check your key and try again.',
+                403: '❌ Your plan has expired. Contact support.',
+            };
+            s.stop(chalk.red(errorMap[res.status] || `❌ Server error (HTTP ${res.status})`));
+            process.exit(1);
+        }
+
+        const data = await res.json();
+        organizationId = data.organizationId || data.organization_id || null;
+
+        s.stop(chalk.green('✅ API Key validated successfully'));
+
+        if (data.plan) {
+            note(
+                chalk.bold.white('📋 Plan: ') + chalk.cyan(data.plan) + '\n' +
+                chalk.bold.white('🏢 Org: ') + chalk.cyan(organizationId || 'N/A'),
+                'Account Info'
+            );
+        }
+    } catch (err) {
+        s.stop(chalk.red(`❌ Could not connect to Arcality backend: ${err.message}`));
+        console.log(chalk.yellow('   Make sure the backend is running and accessible.'));
+        process.exit(1);
+    }
+
+    // ── Step 3: Project details ──
+    const projectName = await text({
+        message: chalk.cyan('📋 Project name:'),
+        placeholder: 'My Portal QA',
+        validate: (v) => {
+            if (!v || v.trim().length < 2) return 'Project name is required (min 2 chars).';
+        },
+    });
+    if (isCancel(projectName)) { cancel('Setup cancelled.'); process.exit(0); }
+
+    const baseUrl = await text({
+        message: chalk.cyan('🌐 Base URL of the application to test:'),
+        placeholder: 'https://staging.example.com',
+        validate: (v) => {
+            if (!v || !v.trim()) return 'Base URL is required.';
+            if (!isValidUrl(v)) return 'Invalid URL. Use http:// or https://';
+        },
+    });
+    if (isCancel(baseUrl)) { cancel('Setup cancelled.'); process.exit(0); }
+
+    const username = await text({
+        message: chalk.cyan('👤 Login username / email:'),
+        validate: (v) => {
+            if (!v || !v.trim()) return 'Username is required.';
+        },
+    });
+    if (isCancel(username)) { cancel('Setup cancelled.'); process.exit(0); }
+
+    const password = await passwordPrompt({
+        message: chalk.cyan('🔒 Login password:'),
+        validate: (v) => {
+            if (!v || !v.length) return 'Password is required.';
+        },
+    });
+    if (isCancel(password)) { cancel('Setup cancelled.'); process.exit(0); }
+
+    // ── Step 4: Detect framework ──
+    const frameworkDetected = detectFramework(projectRoot);
+    if (frameworkDetected) {
+        console.log(chalk.gray(`   🛠️  Framework detected: ${chalk.magenta(frameworkDetected)}`));
+    }
+
+    // ── Step 5: Create project in backend ──
+    const sCreate = spinner();
+    sCreate.start('Creating project in Arcality backend...');
+
+    let projectId = null;
+    try {
+        const payload = {
+            name: projectName.trim(),
+            base_url: baseUrl.trim(),
+            framework_detected: frameworkDetected || undefined,
+            arcality_version: version,
+            config: {
+                source: 'npm-cli',
+                single_configuration_mode: true,
+                yaml_reuse_enabled: true,
+            },
+        };
+
+        const res = await fetch(`${apiUrl}/api/v1/projects`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey.trim(),
+            },
+            body: JSON.stringify(payload),
+        });
+
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '');
+            sCreate.stop(chalk.red(`❌ Failed to create project (HTTP ${res.status}): ${errText}`));
+            process.exit(1);
+        }
+
+        const created = await res.json();
+        projectId = created.id || created.Id;
+        organizationId = organizationId || created.organizationId || created.organization_id || null;
+
+        sCreate.stop(chalk.green(`✅ Project created: "${projectName.trim()}" (${projectId})`));
+    } catch (err) {
+        sCreate.stop(chalk.red(`❌ Error creating project: ${err.message}`));
+        process.exit(1);
+    }
+
+    // ── Step 6: Write arcality.config ──
+    const config = createConfig({
+        apiKey: apiKey.trim(),
+        organizationId,
+        projectId,
+        projectName: projectName.trim(),
+        baseUrl: baseUrl.trim(),
+        frameworkDetected,
+        username: username.trim(),
+        password,
+        arcalityVersion: version,
+    });
+
+    saveProjectConfig(config, projectRoot);
+
+    // ── Summary ──
+    note(
+        chalk.green('✅ arcality.config created successfully!') + '\n\n' +
+        chalk.bold.white('  Project: ') + chalk.cyan(config.project.name) + '\n' +
+        chalk.bold.white('  Base URL: ') + chalk.cyan(config.project.baseUrl) + '\n' +
+        chalk.bold.white('  Framework: ') + chalk.magenta(config.project.frameworkDetected || 'N/A') + '\n' +
+        chalk.bold.white('  Project ID: ') + chalk.gray(config.projectId) + '\n' +
+        chalk.bold.white('  YAML Dir: ') + chalk.yellow(config.runtime.yamlOutputDir),
+        'Configuration Saved'
+    );
+
+    outro(
+        chalk.cyanBright('🚀 Ready! Run ') +
+        chalk.bold.white('arcality run') +
+        chalk.cyanBright(' or ') +
+        chalk.bold.white('arcality') +
+        chalk.cyanBright(' to start testing.')
+    );
+}
+
+main().catch(err => {
+    console.error(chalk.red('  ❌ Error during init:'), err.message);
+    process.exit(1);
+});

package/scripts/migrate-to-central-out.mjs

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.join(__dirname, "..");
+
+function migrate() {
+    const outDirs = fs.readdirSync(PROJECT_ROOT).filter(f => f.startsWith('out_') && fs.statSync(path.join(PROJECT_ROOT, f)).isDirectory());
+    const centralOut = path.join(PROJECT_ROOT, 'out');
+
+    if (!fs.existsSync(centralOut)) fs.mkdirSync(centralOut);
+
+    console.log(`🚀 Starting migration of ${outDirs.length} legacy output directories...`);
+
+    for (const oldDirName of outDirs) {
+        const oldDirPath = path.join(PROJECT_ROOT, oldDirName);
+        const children = fs.readdirSync(oldDirPath);
+
+        // Try to find a config name
+        let configName = oldDirName.replace('out_', '');
+        const configSubDir = children.find(c => fs.statSync(path.join(oldDirPath, c)).isDirectory());
+
+        if (configSubDir) {
+            configName = configSubDir;
+            console.log(`📦 Found configuration folder "${configName}" inside ${oldDirName}`);
+        }
+
+        const newConfigPath = path.join(centralOut, configName);
+        const contextPath = path.join(newConfigPath, 'context');
+        const missionsPath = path.join(newConfigPath, 'missions');
+        const reportsPath = path.join(newConfigPath, 'reports');
+
+        [contextPath, missionsPath, reportsPath].forEach(p => fs.mkdirSync(p, { recursive: true }));
+
+        // Move files
+        children.forEach(child => {
+            const oldChildPath = path.join(oldDirPath, child);
+            const isDir = fs.statSync(oldChildPath).isDirectory();
+
+            if (child === configSubDir) {
+                // Move internals of config subDir to context/projects or similar?
+                // For now, let's just move the whole folder to context
+                moveFolder(oldChildPath, path.join(contextPath, child));
+            } else if (child.startsWith('agent-log') || child.includes('memory') || child.includes('memoria') || child.includes('components-')) {
+                moveFile(oldChildPath, path.join(contextPath, child));
+            } else if (child.endsWith('.yaml') || child.endsWith('.yml')) {
+                moveFile(oldChildPath, path.join(missionsPath, child));
+            } else if (child === 'saved_missions') {
+                const subMissions = fs.readdirSync(oldChildPath);
+                subMissions.forEach(sm => moveFile(path.join(oldChildPath, sm), path.join(missionsPath, sm)));
+                fs.rmdirSync(oldChildPath, { recursive: true });
+            } else {
+                // Default to context
+                if (isDir) moveFolder(oldChildPath, path.join(contextPath, child));
+                else moveFile(oldChildPath, path.join(contextPath, child));
+            }
+        });
+
+        // Remove the old out_ directory if empty
+        if (fs.readdirSync(oldDirPath).length === 0) {
+            fs.rmdirSync(oldDirPath);
+            console.log(`✅ Cleaned up ${oldDirName}`);
+        } else {
+            console.warn(`⚠️ ${oldDirName} not empty after migration.`);
+        }
+    }
+
+    // Move tests/projects folders
+    const projectsDir = path.join(PROJECT_ROOT, 'tests', 'projects');
+    if (fs.existsSync(projectsDir)) {
+        const projects = fs.readdirSync(projectsDir).filter(f => fs.statSync(path.join(projectsDir, f)).isDirectory());
+        console.log(`📁 Migrating ${projects.length} project models from tests/projects...`);
+        for (const pName of projects) {
+            const oldPPath = path.join(projectsDir, pName);
+            // We assume project name matches or is related to a config
+            // If out/[pName] exists, move there
+            const targetConfigPath = path.join(centralOut, pName);
+            const targetContextPath = path.join(targetConfigPath, 'context');
+            if (!fs.existsSync(targetContextPath)) fs.mkdirSync(targetContextPath, { recursive: true });
+
+            moveFolder(oldPPath, path.join(targetContextPath, pName));
+            console.log(`✅ Moved project model "${pName}" to out/${pName}/context/`);
+        }
+        // If empty, remove tests/projects
+        if (fs.readdirSync(projectsDir).length === 0) {
+            fs.rmdirSync(projectsDir);
+        }
+    }
+
+    // Move loose files in central out/ to out/Default/context/
+    const looseFiles = fs.readdirSync(centralOut).filter(f => fs.statSync(path.join(centralOut, f)).isFile());
+    if (looseFiles.length > 0) {
+        console.log(`📄 Migrating ${looseFiles.length} loose files from out/ to out/Default/context/...`);
+        const defaultContext = path.join(centralOut, 'Default', 'context');
+        if (!fs.existsSync(defaultContext)) fs.mkdirSync(defaultContext, { recursive: true });
+        looseFiles.forEach(f => moveFile(path.join(centralOut, f), path.join(defaultContext, f)));
+    }
+
+    // Move global reports
+    const globalReports = ['tests-report', 'playwright-internal-report', 'test-results'];
+    for (const gr of globalReports) {
+        const grPath = path.join(PROJECT_ROOT, gr);
+        if (fs.existsSync(grPath)) {
+            const activeConfig = process.env.ACTIVE_CONFIG || 'Default';
+            const targetDir = path.join(centralOut, activeConfig, 'reports', gr);
+            fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+            moveFolder(grPath, targetDir);
+            console.log(`📊 Moved global report "${gr}" to out/${activeConfig}/reports/`);
+        }
+    }
+
+    console.log('✨ Migration completed successfully.');
+}
+
+function moveFile(src, dest) {
+    if (!fs.existsSync(src)) return;
+    try {
+        fs.renameSync(src, dest);
+    } catch (e) {
+        if (e.code === 'EXDEV') {
+            fs.copyFileSync(src, dest);
+            fs.unlinkSync(src);
+        } else {
+            console.error(`Error moving ${src}:`, e.message);
+        }
+    }
+}
+
+function moveFolder(src, dest) {
+    if (!fs.existsSync(src)) return;
+    try {
+        if (fs.existsSync(dest)) {
+            // Merge content if exists
+            const files = fs.readdirSync(src);
+            files.forEach(f => {
+                const s = path.join(src, f);
+                const d = path.join(dest, f);
+                if (fs.statSync(s).isDirectory()) moveFolder(s, d);
+                else moveFile(s, d);
+            });
+            fs.rmdirSync(src, { recursive: true });
+        } else {
+            fs.renameSync(src, dest);
+        }
+    } catch (e) {
+        if (e.code === 'EXDEV') {
+            fs.cpSync(src, dest, { recursive: true });
+            fs.rmSync(src, { recursive: true });
+        } else {
+            console.error(`Error moving folder ${src}:`, e.message);
+        }
+    }
+}
+
+migrate();

package/scripts/postinstall.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// scripts/postinstall.mjs — Post-install hook
+// Se ejecuta automáticamente después de 'npm install -g @arcadial/arcality'
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.arcality');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+// Leer versión del package.json
+let version = 'unknown';
+try {
+    const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    version = pkg.version || 'unknown';
+} catch { }
+
+console.log('');
+console.log('  ╔══════════════════════════════════════════╗');
+console.log(`  ║   ARCALITY v${version.padEnd(10)} — Instalado ✅    ║`);
+console.log('  ╚══════════════════════════════════════════╝');
+console.log('');
+
+// Crear directorio de config si no existe
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    console.log(`  📁 Directorio creado: ${CONFIG_DIR}`);
+}
+
+// Si no hay config, crear una por defecto (sin key)
+if (!fs.existsSync(CONFIG_FILE)) {
+    const defaultConfig = {
+        api_key: '',
+        version: version,
+        installed_at: new Date().toISOString()
+    };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(defaultConfig, null, 2), 'utf8');
+    console.log(`  📝 Config creada: ${CONFIG_FILE}`);
+    console.log('');
+    console.log('  🔑 Para configurar tu API Key, ejecuta:');
+    console.log('');
+    console.log('     arcality setup');
+    console.log('');
+} else {
+    // Actualizar versión en config existente
+    try {
+        let raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+        if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
+        const config = JSON.parse(raw);
+        config.version = version;
+        config.updated_at = new Date().toISOString();
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+        console.log(`  ✅ Config actualizada (v${version})`);
+    } catch { }
+}
+
+console.log('  📌 Próximos pasos:');
+console.log('     1. arcality setup            → Configura tu API Key y navegador');
+console.log('     2. arcality                   → Abre el menú principal');
+console.log('     3. arcality --agent "misión"  → Ejecuta directamente');
+console.log('');