@arcadialdev/arcality 2.2.0

package/scripts/gen-and-run.mjs

@@ -0,0 +1,838 @@
+#!/usr/bin/env node
+// scripts/gen-and-run.mjs
+// Main Arcality CLI loop — v3 Single Configuration Mode
+// Reads from arcality.config instead of multi-config .env approach.
+
+import 'dotenv/config';
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, exec } from "node:child_process";
+import chalk from "chalk";
+import { fileURLToPath } from 'url';
+import figlet from "figlet";
+import { intro, outro, select, text, spinner, note, isCancel, cancel } from '@clack/prompts';
+import { load as loadYaml } from 'js-yaml';
+import { loadGlobalConfig, getApiKey, getApiUrl, maskApiKey, setupProcessEnv } from '../src/configLoader.mjs';
+import {
+    configExists,
+    loadProjectConfig,
+    validateConfig,
+    injectConfigToEnv,
+    getYamlOutputDir,
+    ensureYamlOutputDir,
+} from '../src/configManager.mjs';
+
+// Load global config at startup (injects keys into process.env)
+setupProcessEnv();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = process.env.ARCALITY_ROOT || path.join(__dirname, "..");
+
+const ORIGINAL_CWD = process.cwd();
+
+// ── Load arcality.config if present ──
+const projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
+if (projectConfig) {
+    injectConfigToEnv(projectConfig);
+}
+
+function parseDotEnvFile(p) {
+    try {
+        const raw = fs.readFileSync(p, 'utf8');
+        const lines = raw.split(/\r?\n/);
+        const out = {};
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) continue;
+            const idx = trimmed.indexOf('=');
+            if (idx === -1) continue;
+            let k = trimmed.slice(0, idx).trim();
+            let v = trimmed.slice(idx + 1).trim();
+            if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+            out[k] = v;
+        }
+        return out;
+    } catch {
+        return {};
+    }
+}
+
+function updateDotEnvFile(updates) {
+    const p = path.join(PROJECT_ROOT, '.env');
+    let content = '';
+    try {
+        content = fs.readFileSync(p, 'utf8');
+    } catch {
+        content = '';
+    }
+
+    let lines = content.split(/\r?\n/);
+    const keys = Object.keys(updates);
+    const updatedKeys = new Set();
+
+    lines = lines.map(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) return line;
+        const idx = trimmed.indexOf('=');
+        if (idx === -1) return line;
+        const k = trimmed.slice(0, idx).trim();
+        if (keys.includes(k)) {
+            updatedKeys.add(k);
+            return `${k}=${updates[k]}`;
+        }
+        return line;
+    });
+
+    keys.forEach(k => {
+        if (!updatedKeys.has(k)) {
+            lines.push(`${k}=${updates[k]}`);
+        }
+    });
+
+    fs.writeFileSync(p, lines.join('\n'), 'utf8');
+    keys.forEach(k => { process.env[k] = updates[k]; });
+}
+
+function setupEnvironment() {
+    // Load API Key from global config
+    const globalConfig = loadGlobalConfig();
+    if (globalConfig?.api_key && !process.env.ARCALITY_API_KEY) {
+        process.env.ARCALITY_API_KEY = globalConfig.api_key;
+    }
+
+    // Use config name from arcality.config or fallback
+    const configName = projectConfig?.project?.name || 'Default';
+    const baseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL || 'http://localhost';
+
+    const rootOutDir = path.join(ORIGINAL_CWD, '.arcality', 'out');
+    const configDir = path.join(rootOutDir, configName.replace(/[^a-zA-Z0-9_-]/g, '_'));
+
+    process.env.DOMAIN_DIR = configDir;
+    process.env.MISSIONS_DIR = path.join(configDir, 'missions');
+    process.env.CONTEXT_DIR = path.join(configDir, 'context');
+    process.env.REPORTS_DIR = path.join(configDir, 'reports');
+
+    [process.env.MISSIONS_DIR, process.env.CONTEXT_DIR, process.env.REPORTS_DIR].forEach(dir => {
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    });
+
+    // Also ensure YAML output dir from arcality.config
+    if (projectConfig) {
+        ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
+    }
+
+    // Framework detection from package.json (NO .git)
+    let techStack = 'Not detected';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['next']) techStack = 'Next.js 🚀';
+        else if (deps['vite']) techStack = 'Vite ⚡';
+        else if (deps['react-scripts']) techStack = 'Create React App ⚛️';
+    } catch { }
+
+    // Override with arcality.config detection if available
+    if (projectConfig?.project?.frameworkDetected) {
+        techStack = projectConfig.project.frameworkDetected;
+    }
+
+    return { configName, baseUrl, techStack, configDir };
+}
+
+function showBanner() {
+    console.clear();
+    const projectName = 'Arcality';
+
+    let version = 'unknown';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
+        version = pkg.version || 'unknown';
+    } catch { }
+
+    const logo = figlet.textSync(projectName, {
+        font: 'Standard',
+        horizontalLayout: 'default',
+        verticalLayout: 'default',
+    });
+
+    intro(chalk.cyanBright(logo));
+
+    note(
+        chalk.magentaBright('Powered by Arcadial') + '\n' +
+        chalk.gray('─'.repeat(50)) + '\n' +
+        chalk.bold.white('📦 Version: ') + chalk.yellow(version),
+        'System Information'
+    );
+
+    const { configName, baseUrl, techStack, configDir } = setupEnvironment();
+
+    // Show arcality.config status instead of multi-config switching
+    const hasConfig = !!projectConfig;
+    const configStatus = hasConfig
+        ? chalk.green('✅ Configured')
+        : chalk.red('❌ Not configured — run `arcality init`');
+
+    const { key: apiKeyVal, source: apiKeySource } = getApiKey();
+    const apiKeyDisplay = apiKeyVal
+        ? chalk.green(maskApiKey(apiKeyVal)) + chalk.gray(` (${apiKeySource})`)
+        : chalk.red('Not configured');
+
+    const infoLines = [
+        chalk.bold.white('⚙️  Environment: ') + chalk.yellow(process.env.NODE_ENV ?? 'development'),
+        chalk.bold.white('🔑 API Key: ') + apiKeyDisplay,
+        chalk.bold.white('🛠️  Stack: ') + chalk.magenta(techStack),
+    ];
+
+    if (hasConfig) {
+        infoLines.splice(1, 0,
+            chalk.bold.white('📋 Project: ') + chalk.cyan(configName) + chalk.gray(` (${baseUrl})`),
+            chalk.bold.white('🆔 Project ID: ') + chalk.gray(projectConfig.projectId || 'N/A'),
+        );
+    } else {
+        infoLines.push(chalk.bold.white('📋 Config: ') + configStatus);
+    }
+
+    note(infoLines.join('\n'), 'Active Configuration');
+}
+
+const ARCALITY_BRAIN_URL = "https://api.anthropic.com/v1/messages";
+const ARCALITY_MODEL = process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022";
+const OUT_DIR = path.join(PROJECT_ROOT, "tests");
+const LOGS_DIR = path.join(PROJECT_ROOT, "logs");
+
+async function arcalityChat(messages) {
+    const internalApiUrl = getApiUrl();
+    const isProxyMode = !!internalApiUrl;
+
+    if (!process.env.ANTHROPIC_API_KEY && !isProxyMode) {
+        throw new Error("Missing ANTHROPIC_API_KEY in .env");
+    }
+
+    const systemMessage = messages.find(m => m.role === 'system');
+    const userMessages = messages.filter(m => m.role !== 'system');
+
+    try {
+        const endpointUrl = isProxyMode
+            ? `${internalApiUrl}/api/v1/ai/proxy`
+            : ARCALITY_BRAIN_URL;
+
+        const headers = {
+            "Content-Type": "application/json"
+        };
+
+        if (isProxyMode) {
+            headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+        } else {
+            headers["x-api-key"] = process.env.ANTHROPIC_API_KEY;
+            headers["anthropic-version"] = "2023-06-01";
+        }
+
+        const res = await fetch(endpointUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: ARCALITY_MODEL,
+                system: systemMessage ? systemMessage.content : undefined,
+                messages: userMessages,
+                max_tokens: 4000,
+                temperature: 0.3
+            })
+        });
+
+        if (!res.ok) {
+            const txt = await res.text();
+            throw new Error(`Arcality Brain Error ${res.status}: ${txt}`);
+        }
+
+        const data = await res.json();
+        const content = data.content?.[0]?.text || "";
+
+        try {
+            if (!fs.existsSync(LOGS_DIR)) fs.mkdirSync(LOGS_DIR, { recursive: true });
+            fs.writeFileSync(path.join(LOGS_DIR, 'last-ai-response.txt'), content);
+        } catch (e) { /* ignore */ }
+
+        return content;
+    } catch (err) {
+        throw new Error(`Error communicating with Arcality brain: ${err.message}`);
+    }
+}
+
+function extractBlocks(text) {
+    const cleaned = text
+        .replace(/```[a-zA-Z]*\n?/g, "")
+        .replace(/```/g, "")
+        .trim();
+
+    const fnMatch = cleaned.match(/^FILENAME:\s*(.+)$/m);
+    const contentIdx = cleaned.indexOf("CONTENT:");
+
+    if (!fnMatch || contentIdx === -1) {
+        throw new Error(
+            `Invalid format. Expected:\nFILENAME: <file.spec.ts>\nCONTENT:\n<code>\n\nResponse:\n${cleaned}`
+        );
+    }
+
+    const filename = fnMatch[1].trim();
+    const content = cleaned.slice(contentIdx + "CONTENT:".length).trim();
+
+    return { filename, content, cleaned };
+}
+
+function validateSpec(ts) {
+    const errors = [];
+    if (!/test\s*\(.*async\s*\(\s*\{\s*page\s*\}\s*\)\s*=>/s.test(ts)) {
+        errors.push('Missing fixture: test("...", async ({ page }) => { ... })');
+    }
+    if (/from\s+['"]playwright['"]/.test(ts)) {
+        errors.push("Forbidden to import from core. Use only the Arcality SDK.");
+    }
+    if (!ts.includes("import { test, expect } from '@playwright/test'")) {
+        errors.push("Must import exactly the Arcality engine.");
+    }
+    return errors;
+}
+
+function sanitizeFilename(name, fallback) {
+    if (typeof name !== "string") return fallback;
+    const safe = name.trim().replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
+    if (!safe.endsWith(".spec.ts")) return fallback;
+    return safe;
+}
+
+function run(cmd, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const appNodeModules = path.join(PROJECT_ROOT, 'node_modules');
+        const existingNodePath = process.env.NODE_PATH || '';
+        const newNodePath = existingNodePath ? `${appNodeModules}${path.delimiter}${existingNodePath}` : appNodeModules;
+
+        const p = spawn(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: process.platform === "win32",
+            windowsHide: true,
+            env: { ...options.env || process.env, NODE_PATH: newNodePath },
+        });
+
+        let outputBuffer = '';
+        p.stdout.on('data', (data) => {
+            const str = data.toString();
+            if (str.includes('>>ARCALITY_STATUS>>')) {
+                const lines = str.split('\n');
+                for (const line of lines) {
+                    if (line.includes('>>ARCALITY_STATUS>>')) {
+                        const status = line.split('>>ARCALITY_STATUS>>')[1].trim();
+                        if (options.onStatus) options.onStatus(status);
+                    } else if (line.trim()) {
+                        process.stdout.write(line + '\n');
+                    }
+                }
+            } else {
+                process.stdout.write(data);
+            }
+            outputBuffer += str;
+        });
+
+        p.stderr.on('data', (data) => {
+            process.stderr.write(data);
+            outputBuffer += data.toString();
+        });
+
+        p.on("exit", (code) => {
+            const lastRunLog = path.join(LOGS_DIR, 'last-run.log');
+            try {
+                if (!fs.existsSync(LOGS_DIR)) fs.mkdirSync(LOGS_DIR, { recursive: true });
+                fs.writeFileSync(lastRunLog, outputBuffer);
+            } catch (e) { }
+
+            if (code === 0) resolve();
+            else reject(new Error(`Command failed (${code}): ${cmd} ${args.join(" ")}`));
+        });
+    });
+}
+
+/**
+ * Ping the project to register activity.
+ * Uses internal API URL — not user-configurable.
+ */
+async function pingProject(projectId, apiKey) {
+    if (!projectId || !apiKey) return;
+    try {
+        await fetch(`${getApiUrl()}/api/v1/projects/${projectId}/ping`, {
+            method: 'PATCH',
+            headers: { 'x-api-key': apiKey },
+        });
+    } catch { /* silent */ }
+}
+
+async function main() {
+    process.chdir(PROJECT_ROOT);
+
+    // Backward compat: initialize .env if ACTIVE_CONFIG missing (legacy)
+    let initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+    if (!projectConfig && !initialEnv.ACTIVE_CONFIG) {
+        updateDotEnvFile({
+            ACTIVE_CONFIG: 'Default',
+            SAVED_CONFIGS: 'Default',
+            Default_URL: initialEnv.BASE_URL || '',
+            Default_USER: initialEnv.LOGIN_USER || '',
+            Default_PASS: initialEnv.LOGIN_PASSWORD || ''
+        });
+        initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+    }
+
+    const argv = process.argv.slice(2);
+    let initialDiscoverPath = null;
+    let initialSmartMode = false;
+    let initialAgentMode = false;
+
+    const dIndex = argv.findIndex(a => a === '--discover' || a.startsWith('--discover='));
+    if (dIndex !== -1) {
+        const token = argv[dIndex];
+        if (token.includes('=')) initialDiscoverPath = token.split('=')[1];
+        else if (argv[dIndex + 1]) { initialDiscoverPath = argv[dIndex + 1]; argv.splice(dIndex + 1, 1); }
+        argv.splice(dIndex, 1);
+    }
+    const sIndex = argv.findIndex(a => a === '--smart');
+    if (sIndex !== -1) { initialSmartMode = true; argv.splice(sIndex, 1); }
+    const aIndex = argv.findIndex(a => a === '--agent');
+    if (aIndex !== -1) { initialAgentMode = true; argv.splice(aIndex, 1); }
+
+    const promptArg = argv.join(" ").trim();
+    let firstRun = true;
+    let globalReportProcess = null;
+
+    setupEnvironment();
+
+    while (true) {
+        let prompt = firstRun ? promptArg : "";
+        let agentMode = firstRun ? initialAgentMode : false;
+        let smartMode = firstRun ? initialSmartMode : false;
+        let discoverPath = firstRun ? initialDiscoverPath : null;
+
+        let skipMenu = firstRun && (prompt || agentMode || smartMode);
+        firstRun = false;
+
+        if (!skipMenu) {
+            showBanner();
+            try {
+                // ── Build menu options (single config mode) ──
+                const missionsDir = process.env.MISSIONS_DIR;
+                const savedMissions = fs.existsSync(missionsDir)
+                    ? fs.readdirSync(missionsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+                    : [];
+
+                // Check for YAML files in the yaml output dir from arcality.config
+                let yamlOutputFiles = [];
+                if (projectConfig) {
+                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
+                    if (fs.existsSync(yamlDir)) {
+                        yamlOutputFiles = fs.readdirSync(yamlDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+                    }
+                }
+
+                // Root-level YAML templates
+                const rootYamlFiles = fs.readdirSync(PROJECT_ROOT).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+
+                const options = [
+                    { label: '🤖 Run Autonomous Agent (Prompt)', value: 'agent' },
+                    ...(savedMissions.length ? [{ label: '🚀 Launch Saved Mission (.yaml)', value: 'launch_saved' }] : []),
+                    ...(yamlOutputFiles.length ? [{ label: '♻️  Reuse Successful YAML', value: 'reuse_yaml' }] : []),
+                    ...(rootYamlFiles.length ? [{ label: '📂 Choose Root YAML (Templates)', value: 'yaml_list' }] : []),
+                    { label: '📋 View Current Configuration', value: 'view_config' },
+                    { label: '🔄 Reconfigure (arcality init)', value: 'reconfigure' },
+                    { label: '❌ Exit', value: 'exit' }
+                ];
+
+                const action = await select({
+                    message: 'What would you like to do?',
+                    options
+                });
+
+                if (isCancel(action) || action === 'exit') {
+                    outro(chalk.cyan('See you later!'));
+                    break;
+                }
+
+                if (action === 'agent') {
+                    agentMode = true;
+                } else if (action === 'view_config') {
+                    if (projectConfig) {
+                        note(
+                            chalk.bold.white('📋 Project: ') + chalk.cyan(projectConfig.project?.name) + '\n' +
+                            chalk.bold.white('🌐 Base URL: ') + chalk.cyan(projectConfig.project?.baseUrl) + '\n' +
+                            chalk.bold.white('🛠️  Framework: ') + chalk.magenta(projectConfig.project?.frameworkDetected || 'N/A') + '\n' +
+                            chalk.bold.white('🆔 Project ID: ') + chalk.gray(projectConfig.projectId) + '\n' +
+                            chalk.bold.white('🏢 Org ID: ') + chalk.gray(projectConfig.organizationId || 'N/A') + '\n' +
+                            chalk.bold.white('👤 User: ') + chalk.cyan(projectConfig.auth?.username) + '\n' +
+                            chalk.bold.white('📂 YAML Dir: ') + chalk.yellow(projectConfig.runtime?.yamlOutputDir) + '\n' +
+                            chalk.bold.white('♻️  Reuse YAMLs: ') + chalk.cyan(projectConfig.runtime?.reuseSuccessfulYamls ? '✅' : '❌') + '\n' +
+                            chalk.bold.white('📦 Version: ') + chalk.yellow(projectConfig.meta?.arcalityVersion || 'N/A'),
+                            'arcality.config'
+                        );
+                    } else {
+                        note(
+                            chalk.yellow('No arcality.config found.') + '\n' +
+                            chalk.gray('Run `arcality init` to configure this project.'),
+                            'No Configuration'
+                        );
+                    }
+                    continue;
+                } else if (action === 'reconfigure') {
+                    // Launch arcality init in the user's project directory
+                    const initScript = path.join(PROJECT_ROOT, 'scripts', 'init.mjs');
+                    try {
+                        await new Promise((resolve, reject) => {
+                            const child = spawn('node', [initScript], {
+                                stdio: 'inherit',
+                                cwd: ORIGINAL_CWD,
+                                env: { ...process.env, ARCALITY_ROOT: PROJECT_ROOT }
+                            });
+                            child.on('exit', code => code === 0 ? resolve() : reject(new Error(`Init exited with ${code}`)));
+                            child.on('error', reject);
+                        });
+                    } catch { /* user cancelled or error */ }
+                    continue;
+                } else if (action === 'launch_saved') {
+                    const sel = await select({
+                        message: 'Choose saved mission:',
+                        options: savedMissions.map(f => ({ label: f, value: f }))
+                    });
+                    if (isCancel(sel)) continue;
+
+                    const yamlContent = fs.readFileSync(path.join(missionsDir, sel), 'utf8');
+                    const data = loadYaml(yamlContent);
+                    prompt = data.prompt || data.mision || yamlContent;
+                    agentMode = true;
+                } else if (action === 'reuse_yaml') {
+                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
+                    const sel = await select({
+                        message: 'Choose YAML to reuse:',
+                        options: yamlOutputFiles.map(f => ({ label: f, value: f }))
+                    });
+                    if (isCancel(sel)) continue;
+
+                    const yamlContent = fs.readFileSync(path.join(yamlDir, sel), 'utf8');
+                    const data = loadYaml(yamlContent);
+                    prompt = data.prompt || data.mision || yamlContent;
+                    agentMode = true;
+                } else if (action === 'yaml_list') {
+                    const sel = await select({
+                        message: 'Choose YAML file:',
+                        options: rootYamlFiles.map(f => ({ label: f, value: f }))
+                    });
+                    if (isCancel(sel)) continue;
+
+                    const yamlContent = fs.readFileSync(path.join(PROJECT_ROOT, sel), 'utf8');
+                    const data = loadYaml(yamlContent);
+                    prompt = data.mision || data.prompt || yamlContent;
+                    agentMode = true;
+                }
+            } catch (e) {
+                console.error("Menu error:", e);
+                break;
+            }
+        }
+
+        // --- VALIDATION AND CAPTURE OF PARAMETERS FOR THE AGENT ---
+        if (agentMode) {
+            if (!prompt || prompt.trim().length < 4) {
+                const p = await text({
+                    message: chalk.cyan('🤖 Mission for the Agent (Required):'),
+                    placeholder: 'E.g., Fill the signup form with random data',
+                    validate: v => {
+                        if (!v || !v.trim()) return 'The mission is required to start.';
+                        if (v.trim().length < 4) return 'The mission must be more descriptive (minimum 4 characters).';
+                    }
+                });
+
+                if (isCancel(p)) {
+                    cancel('Mission cancelled. Returning to main menu...');
+                    agentMode = false;
+                    prompt = "";
+                    skipMenu = false;
+                    continue;
+                }
+                prompt = p;
+            }
+
+            if (!discoverPath) {
+                const d = await text({
+                    message: chalk.cyan('🌐 Initial navigation path:'),
+                    initialValue: '/',
+                    placeholder: '/'
+                });
+                if (isCancel(d)) {
+                    cancel('Mission aborted. Returning to menu...');
+                    agentMode = false;
+                    prompt = "";
+                    skipMenu = false;
+                    continue;
+                }
+                discoverPath = d;
+            }
+        }
+
+        if (agentMode) {
+            const dotEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+
+            // ── API Key and Quota Validation ──
+            const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
+
+            const validation = await validateApiKey();
+            if (!validation.valid) {
+                const errorMessages = {
+                    'no_api_key': '🔑 API Key not found.\n   Configure it via `arcality init` or in .env (ARCALITY_API_KEY)',
+                    'invalid_format': '🔑 Invalid API Key. It must start with "arc_k_"',
+                    'invalid_api_key': '🔑 API Key not recognized by the server',
+                    'plan_expired': '💳 Your plan has expired'
+                };
+                note(chalk.red(errorMessages[validation.error] || `Error: ${validation.error}`), '❌ Authentication');
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            // Show plan info
+            const modeLabel = validation.mode === 'mock' ? chalk.gray('(local)') : chalk.green('(live)');
+            const dailyLimitDisplay = validation.daily_limit === -1 ? '∞' : (validation.daily_limit || 50);
+            const remainingDisplay = validation.remaining >= 999999 ? '∞' : validation.remaining;
+            note(
+                chalk.bold.white('✅ Valid API Key ') + modeLabel + '\n' +
+                chalk.bold.white('📋 Plan: ') + chalk.cyan(validation.plan || 'internal') + '\n' +
+                chalk.bold.white('📊 Missions today: ') + chalk.yellow(`${validation.daily_used || 0}/${dailyLimitDisplay}`) + '\n' +
+                chalk.bold.white('🎯 Remaining: ') + chalk.green(remainingDisplay),
+                'Arcality Account'
+            );
+
+            // --- RESOLVE PROJECT ID ---
+            let selectedProjectId = projectConfig?.projectId || dotEnv.ARCALITY_PROJECT_ID || process.env.ARCALITY_PROJECT_ID;
+            const apiBase = getApiUrl();
+
+            if (!selectedProjectId) {
+                // If no project ID from config, try to create/select from backend
+                try {
+                    const projRes = await fetch(`${apiBase}/api/v1/projects`, {
+                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' }
+                    });
+
+                    if (projRes.ok) {
+                        const data = await projRes.json();
+                        const projects = data.projects || [];
+
+                        const projOptions = projects.map(p => ({ label: p.name || p.Name, value: p.id || p.Id }));
+                        projOptions.push({ label: '➕ Create new project', value: 'new' });
+
+                        const projSelection = await select({
+                            message: chalk.cyan('Choose a project for this mission:'),
+                            options: projOptions
+                        });
+
+                        if (isCancel(projSelection)) {
+                            cancel('Mission aborted.');
+                            agentMode = false; prompt = ""; skipMenu = false; continue;
+                        }
+
+                        if (projSelection === 'new') {
+                            const newName = await text({ message: 'Project name:', validate: v => !v ? 'Required' : undefined });
+                            if (isCancel(newName)) { cancel('Aborted'); agentMode = false; prompt = ""; skipMenu = false; continue; }
+
+                            const createRes = await fetch(`${apiBase}/api/v1/projects`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.ARCALITY_API_KEY || '' },
+                                body: JSON.stringify({
+                                    name: newName,
+                                    base_url: projectConfig?.project?.baseUrl || discoverPath || '/',
+                                    arcality_version: projectConfig?.meta?.arcalityVersion || 'unknown',
+                                    config: { source: 'npm-cli', single_configuration_mode: true, yaml_reuse_enabled: true }
+                                })
+                            });
+
+                            if (createRes.ok) {
+                                const created = await createRes.json();
+                                selectedProjectId = created.id || created.Id;
+                                note(chalk.green(`✅ Project created: ${newName}`));
+                            } else {
+                                note(chalk.red(`❌ Failed to create project.`));
+                            }
+                        } else {
+                            selectedProjectId = projSelection;
+                        }
+
+                        if (selectedProjectId) {
+                            process.env.ARCALITY_PROJECT_ID = selectedProjectId;
+                        }
+                    }
+                } catch (e) {
+                    console.log(chalk.yellow(`\n⚠️ Error connecting to project server: ${e.message}. Using default.`));
+                }
+            } else {
+                process.env.ARCALITY_PROJECT_ID = selectedProjectId;
+            }
+
+            // ── Start Mission ──
+            const mission = await requestMission(prompt, discoverPath || '/');
+            if (!mission.allowed) {
+                note(
+                    chalk.red(`❌ ${mission.error === 'mission_limit_exceeded' ? 'Daily mission limit reached' : mission.error}`) + '\n' +
+                    chalk.yellow(`📊 Used: ${mission.daily_used}/${mission.daily_limit}`) + '\n' +
+                    chalk.gray(`🔄 Resets: ${mission.resets_at ? new Date(mission.resets_at).toLocaleString() : 'tomorrow'}`),
+                    '⚠️ Limit Reached'
+                );
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            const s = spinner();
+            s.start(`🤖 [AGENT MODE] Starting mission: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit} today)`)}`);
+
+            const finalProjectId = process.env.ARCALITY_PROJECT_ID || selectedProjectId;
+
+            // Build env for the runner — merge arcality.config values
+            const mergedEnv = {
+                ...dotEnv,
+                ...process.env,
+                ARCALITY_PROJECT_ID: finalProjectId,
+                BASE_URL: projectConfig?.project?.baseUrl || dotEnv.BASE_URL || process.env.BASE_URL,
+                LOGIN_USER: projectConfig?.auth?.username || dotEnv.LOGIN_USER || process.env.LOGIN_USER,
+                LOGIN_PASSWORD: projectConfig?.auth?.password || dotEnv.LOGIN_PASSWORD || process.env.LOGIN_PASSWORD,
+                DOMAIN_DIR: process.env.DOMAIN_DIR,
+                MISSIONS_DIR: process.env.MISSIONS_DIR,
+                CONTEXT_DIR: process.env.CONTEXT_DIR,
+                REPORTS_DIR: process.env.REPORTS_DIR,
+                SMART_PROMPT: prompt,
+                TARGET_PATH: discoverPath || '/'
+            };
+
+            if (finalProjectId) {
+                console.log(chalk.gray(`\n>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+            }
+
+            try {
+                await run("npx", ["playwright", "test", "tests/_helpers/agentic-runner.spec.ts", "--headed"], {
+                    env: mergedEnv,
+                    onStatus: (msg) => s.message(msg)
+                });
+                s.stop(chalk.green('✅ Mission completed successfully.'));
+
+                // ── End Mission ──
+                const { endMission } = await import('../src/arcalityClient.mjs');
+                await endMission(mission.mission_id, 'success');
+
+                // ── Ping Project ──
+                await pingProject(finalProjectId, process.env.ARCALITY_API_KEY);
+
+                // ── Save Mission YAML ──
+                const saveDecision = await select({
+                    message: 'Do you want to save this mission to run it again later?',
+                    options: [
+                        { label: '✅ Yes, save as YAML', value: 'yes' },
+                        { label: '❌ No, thanks', value: 'no' }
+                    ]
+                });
+
+                if (saveDecision === 'yes') {
+                    const name = await text({
+                        message: 'Mission name (e.g., valid_login):',
+                        placeholder: 'my_mission',
+                        validate: v => v.length < 3 ? 'Name too short' : undefined
+                    });
+
+                    if (!isCancel(name)) {
+                        const safeName = name.trim().replace(/[^a-z0-9]/gi, '_').toLowerCase();
+
+                        // Save to missions dir (existing flow)
+                        const missionsDir = process.env.MISSIONS_DIR;
+                        const yamlPathMissions = path.join(missionsDir, `${safeName}.yaml`);
+
+                        let yamlData = `name: "${name}"\nprompt: "${prompt}"\nproject: "${projectConfig?.project?.name || 'Default'}"\ncreated_at: "${new Date().toISOString()}"\n`;
+
+                        const smartYamlPath = path.join(process.env.CONTEXT_DIR, 'last-mission-smart.yaml');
+                        if (fs.existsSync(smartYamlPath)) {
+                            yamlData = fs.readFileSync(smartYamlPath, 'utf8');
+                        }
+
+                        // Internal fallback backup for the agent
+                        fs.writeFileSync(yamlPathMissions, yamlData);
+
+                        // Primary save to user's specified directory from arcality.config
+                        if (projectConfig) {
+                            const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
+                            const yamlPathOutput = path.join(yamlOutputDir, `${safeName}.yaml`);
+                            fs.writeFileSync(yamlPathOutput, yamlData);
+                            note(chalk.green(`✅ Mission saved at: ${yamlPathOutput}`), 'Arcality Persistence');
+                        } else {
+                            note(chalk.green(`✅ Mission saved at: ${yamlPathMissions}`), 'Arcality Persistence');
+                        }
+                    }
+                }
+            } catch (e) {
+                s.stop(chalk.red('❌ Mission could not be completed.'));
+
+                // End mission with failure
+                try {
+                    const { endMission } = await import('../src/arcalityClient.mjs');
+                    await endMission(mission.mission_id, 'failed');
+                } catch { }
+            } finally {
+                const sRep = spinner();
+                sRep.start('📊 Generating report...');
+                await run("node", ["scripts/rebrand-report.mjs"]).catch(() => { });
+
+                const reportDir = process.env.REPORTS_DIR || 'tests-report';
+                const arcalityPath = path.resolve(PROJECT_ROOT, reportDir, 'index.html');
+
+                if (globalReportProcess) {
+                    try {
+                        if (process.platform === "win32") {
+                            spawn("taskkill", ["/pid", globalReportProcess.pid, "/f", "/t"], { stdio: 'ignore', windowsHide: true });
+                        } else {
+                            globalReportProcess.kill();
+                        }
+                    } catch (e) { /* ignore */ }
+                    globalReportProcess = null;
+                }
+
+                console.log(chalk.blue(`🌐 Opening Arcality Report: ${arcalityPath}`));
+
+                if (process.platform === "win32") {
+                    exec(`start "" "${arcalityPath}"`);
+                } else {
+                    exec(`open "${arcalityPath}"`);
+                }
+
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                sRep.stop(chalk.cyan('Report process initialized.'));
+
+                // Ping project after report
+                await pingProject(
+                    process.env.ARCALITY_PROJECT_ID,
+                    process.env.ARCALITY_API_KEY
+                );
+
+                await text({
+                    message: 'Press Enter to return to menu...',
+                    placeholder: 'Enter'
+                });
+
+                if (skipMenu) {
+                    outro(chalk.cyan('Mission finished! See you later.'));
+                    return;
+                }
+
+                agentMode = false;
+                prompt = "";
+                firstRun = false;
+            }
+        }
+        firstRun = false;
+    }
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});