@arcadialdev/arcality 2.4.37 → 2.4.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcadialdev/arcality",
-  "version": "2.4.37",
-  "description": "AI-powered QA testing tool — Autonomous web testing agent by Arcadial",
+  "version": "2.4.49",
+  "description": "El primer ingeniero QA Autónomo integrado al CI/CD. Creado por Arcadial.",
   "main": "index.js",
   "scripts": {
     "dev": "node scripts/gen-and-run.mjs",
@@ -51,9 +51,11 @@
     "@types/figlet": "^1.7.0",
     "@types/node": "^25.0.9",
     "@types/prompts": "^2.4.9",
-    "esbuild": "^0.20.2"
+    "esbuild": "^0.20.2",
+    "typescript": "^6.0.3"
   },
   "dependencies": {
+    "@azure/storage-blob": "^12.31.0",
     "@clack/prompts": "^1.0.1",
     "@inquirer/prompts": "^8.2.0",
     "@playwright/test": "^1.57.0",
@@ -62,9 +64,10 @@
     "dotenv": "^17.2.3",
     "figlet": "^1.9.4",
     "js-yaml": "^4.1.1",
+    "mime-types": "^3.0.2",
     "node-fetch": "^3.3.2",
     "prompts": "^2.4.2",
     "terminal-image": "^1.1.0",
     "tsx": "^4.21.0"
   }
-}
+}

package/scripts/gen-and-run.mjs

@@ -34,7 +34,7 @@ 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);
+let projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
 if (projectConfig) {
     injectConfigToEnv(projectConfig);
 }
@@ -324,6 +324,9 @@ function run(cmd, args, options = {}) {
             env,
         });
 
+        // Exponer el proceso hijo para que el cancelHandler pueda matarlo
+        if (options.onSpawn) options.onSpawn(p);
+
         let outputBuffer = '';
         const handleData = (data) => {
             const str = data.toString();
@@ -467,7 +470,6 @@ async function main() {
                     ...(savedMissions.length ? [{ label: '🚀 Launch Saved Mission (.yaml)', value: 'launch_saved' }] : []),
                     ...(yamlOutputFiles.length ? [{ label: '♻️  Reuse YAML + Auto-Guide (if prev. run exists)', 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' }
                 ];
@@ -484,28 +486,6 @@ async function main() {
 
                 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');
@@ -519,7 +499,20 @@ async function main() {
                             child.on('exit', code => code === 0 ? resolve() : reject(new Error(`Init exited with ${code}`)));
                             child.on('error', reject);
                         });
-                    } catch { /* user cancelled or error */ }
+                        
+                        // ── REFRESH CONFIG ──
+                        // Recargar el archivo que init.mjs acaba de escribir
+                        projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
+                        if (projectConfig) {
+                            injectConfigToEnv(projectConfig);
+                        }
+                        setupEnvironment();
+                        
+                    } catch (e) {
+                        // Mostrar el error claramente antes de que console.clear() lo borre
+                        console.log(chalk.red(`\n❌ Reconfigure failed: ${e.message}`));
+                        await new Promise(r => setTimeout(r, 3000));
+                    }
                     continue;
                 } else if (action === 'launch_saved') {
                     const sel = await select({
@@ -620,6 +613,14 @@ async function main() {
             const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
 
             const validation = await validateApiKey();
+            if (process.env.DEBUG || process.argv.includes('--debug')) {
+                console.log(chalk.gray(`[DEBUG] Validation result: ${JSON.stringify(validation, null, 2)}`));
+            }
+            
+            const detectedOrgId = validation.organization_id || validation.organizationId || validation.OrganizationId;
+            if (detectedOrgId) {
+                process.env.ARCALITY_ORG_ID = detectedOrgId;
+            }
             if (!validation.valid) {
                 const errorMessages = {
                     'no_api_key': '🔑 API Key not found.\n   Configure it via `arcality init` or in .env (ARCALITY_API_KEY)',
@@ -636,7 +637,7 @@ async function main() {
 
             // 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 dailyLimitDisplay = validation.daily_limit === -1 ? '∞' : (validation.daily_limit || 35);
             const remainingDisplay = validation.remaining >= 999999 ? '∞' : validation.remaining;
             note(
                 chalk.bold.white('✅ Valid API Key ') + modeLabel + '\n' +
@@ -653,9 +654,13 @@ async function main() {
             if (!selectedProjectId) {
                 // If no project ID from config, try to create/select from backend
                 try {
+                    const projController = new AbortController();
+                    const projTimeout = setTimeout(() => projController.abort(), 5000);
                     const projRes = await fetch(`${apiBase}/api/v1/projects`, {
-                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' }
+                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' },
+                        signal: projController.signal
                     });
+                    clearTimeout(projTimeout);
 
                     if (projRes.ok) {
                         const data = await projRes.json();
@@ -735,6 +740,63 @@ async function main() {
 
             const finalProjectId = process.env.ARCALITY_PROJECT_ID || selectedProjectId;
 
+            // ── SIGINT Handler: Cancelación manual (Ctrl+C / ESC) ──
+            // Se registra AQUÍ, justo antes del spawn, para que solo aplique durante la ejecución.
+            // Al cancelar: mata el proceso hijo, guarda estado "canceled", llama endMission y genera reporte.
+            let activeChildProcess = null;  // Referencia al proceso hijo de Playwright
+            let userCanceledMission = false;
+            const cancelHandler = async () => {
+                if (userCanceledMission) return; // Evitar doble disparo
+                userCanceledMission = true;
+
+                console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Misión cancelada por el usuario.'));
+                if (!process.argv.includes('--debug')) s.stop(chalk.yellow('⚠️  Misión cancelada por el usuario.'));
+
+                // 1. Escribir un agent-log de cancelación para que el reporte lo refleje
+                try {
+                    const ctxDir = process.env.CONTEXT_DIR;
+                    if (ctxDir && fs.existsSync(ctxDir)) {
+                        const cancelLog = {
+                            prompt,
+                            history: ['[CANCELADO POR USUARIO] La prueba fue detenida manualmente antes de completarse.'],
+                            steps: 0,
+                            success: false,
+                            error: true,
+                            fail_reason: 'user_canceled',
+                            canceled_by_user: true,
+                            timestamp: new Date().toISOString()
+                        };
+                        fs.writeFileSync(path.join(ctxDir, `agent-log-${Date.now()}.json`), JSON.stringify(cancelLog, null, 2));
+                    }
+                } catch { /* silencioso */ }
+
+                // 2. Llamar endMission con estado 'canceled'
+                try {
+                    const { endMission: endM } = await import('../src/arcalityClient.mjs');
+                    await endM(mission.mission_id, 'canceled', null, 'user_canceled');
+                    console.log(chalk.gray('   >> Misión registrada como "cancelada" en el servidor.'));
+                } catch { /* silencioso si el backend no está disponible */ }
+
+                // 3. Matar el proceso hijo de Playwright — hacerlo AL FINAL para dar tiempo
+                //    a que el agente-log y endMission terminen antes del kill.
+                //    NO llamar process.exit() aquí: el finally del try/catch principal
+                //    se encarga de generar el reporte visual y abrirlo en el browser.
+                if (activeChildProcess) {
+                    try {
+                        if (process.platform === 'win32') {
+                            spawn('taskkill', ['/pid', activeChildProcess.pid, '/f', '/t'], { stdio: 'ignore', windowsHide: true });
+                        } else {
+                            activeChildProcess.kill('SIGTERM');
+                        }
+                    } catch { /* silencioso */ }
+                }
+                // El bloque finally del try/catch de run() tomará el control
+                // a partir de aquí (el proceso hijo ya terminó → run() rechaza → catch → finally).
+            };
+
+            process.once('SIGINT', cancelHandler);
+            process.once('SIGTERM', cancelHandler);
+
             // Build env for the runner — merge arcality.config values.
             // ARCALITY_API_URL must be explicit — it comes from the library's internal config,
             // not from the user's project .env, so we inject it directly via getApiUrl().
@@ -745,7 +807,8 @@ async function main() {
                 ...process.env,
                 ARCALITY_API_URL: getApiUrl(),          // Internal URL — always injected explicitly
                 ARCALITY_PROJECT_ID: finalProjectId,
-                ARCALITY_MISSION_ID: mission.mission_id || '',  // ← Propagate mission_id to every proxy call
+                ARCALITY_MISSION_ID: mission.mission_id || mission.missionId || mission.MissionId || '',  // ← Propagate mission_id to every proxy call
+                ARCALITY_ORG_ID: validation.organization_id || validation.organizationId || validation.OrganizationId || process.env.ARCALITY_ORG_ID || '',  // ← Propagate org_id for pattern persistence
                 BASE_URL: projectConfig?.project?.baseUrl || dotEnv.BASE_URL || process.env.BASE_URL || fallbackBaseUrl || 'http://localhost:3000',
                 LOGIN_USER: projectConfig?.auth?.username || dotEnv.LOGIN_USER || process.env.LOGIN_USER,
                 LOGIN_PASSWORD: projectConfig?.auth?.password || dotEnv.LOGIN_PASSWORD || process.env.LOGIN_PASSWORD,
@@ -758,7 +821,8 @@ async function main() {
             };
 
             if (finalProjectId) {
-                console.log(chalk.gray(`\n>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+                console.log(chalk.gray(`>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+                console.log(chalk.gray(`>> ARCALITY_ORG_ID: ${mergedEnv.ARCALITY_ORG_ID || 'NONE'}`));
             }
 
             // ── Resolve execution paths ──
@@ -798,16 +862,20 @@ async function main() {
                     '--headed',
                     '--config', 'playwright.config.js'
                 ], {
-                    cwd: PROJECT_ROOT,   // Run from the arcality package root
+                    cwd: PROJECT_ROOT,
                     env: mergedEnv,
-                    onStatus: (msg) => { if (!process.argv.includes('--debug')) s.message(msg); else console.log(chalk.gray(`>> Status: ${msg}`)); }
+                    onStatus: (msg) => { if (!process.argv.includes('--debug')) s.message(msg); else console.log(chalk.gray(`>> Status: ${msg}`)); },
+                    onSpawn: (child) => { activeChildProcess = child; }  // ← Capturar referencia para cancelHandler
                 });
+
+                // Eliminar handlers SIGINT ahora que el proceso terminó normalmente
+                process.off('SIGINT', cancelHandler);
+                process.off('SIGTERM', cancelHandler);
+
+                if (userCanceledMission) return; // El handler ya tomó el control
                 if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Mission completed successfully.'));
                 else console.log(chalk.green('✅ Mission completed successfully.'));
 
-                // ── End Mission ──
-                const { endMission } = await import('../src/arcalityClient.mjs');
-                
                 let finalUsage = undefined;
                 try {
                     const ctxDir = process.env.CONTEXT_DIR;
@@ -822,6 +890,27 @@ async function main() {
                     }
                 } catch(e) {}
 
+                // ── Upload Evidence ──
+                const { endMission, getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
+                const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
+
+                try {
+                    const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
+                    if (sasData && sasData.sasUrl) {
+                        if (!process.argv.includes('--debug')) s.start('☁️  Uploading evidence to Azure...');
+                        const reportsDir = process.env.REPORTS_DIR || path.join(ORIGINAL_CWD, 'tests-report');
+                        
+                        await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
+                        
+                        await uploadEvidence(reportsDir, sasData.sasUrl, sasData.basePath);
+                        if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Evidence uploaded successfully.'));
+                    }
+                } catch (e) {
+                    if (process.argv.includes('--debug')) console.log(chalk.yellow(`⚠️  Could not upload evidence: ${e.message}`));
+                    if (!process.argv.includes('--debug')) s.stop(chalk.yellow('⚠️  Evidence upload failed.'));
+                }
+
+                // ── End Mission ──
                 await endMission(mission.mission_id, 'success', finalUsage);
 
                 // ── Ping Project ──
@@ -873,31 +962,66 @@ async function main() {
                     }
                 }
             } catch (e) {
-                s.stop(chalk.red(`❌ Mission could not be completed.`));
-                console.error(chalk.red(`\nError Details: ${e.message}`));
-                if (e.stack && process.argv.includes('--debug')) {
-                    console.error(chalk.gray(e.stack));
-                }
+                // Eliminar handlers SIGINT en el path de error también
+                process.off('SIGINT', cancelHandler);
+                process.off('SIGTERM', cancelHandler);
+
+                if (userCanceledMission) {
+                    // El cancelHandler ya registró la cancelación en el servidor.
+                    // Solo mostramos un mensaje y dejamos que el finally genere el reporte.
+                    console.log(chalk.yellow('\n⚠️  Misión cancelada — generando reporte de evidencia...'));
+                } else {
+                    s.stop(chalk.red(`❌ Mission could not be completed.`));
+                    console.error(chalk.red(`\nError Details: ${e.message}`));
+                    if (e.stack && process.argv.includes('--debug')) {
+                        console.error(chalk.gray(e.stack));
+                    }
 
-                // End mission with failure
-                try {
-                    const { endMission } = await import('../src/arcalityClient.mjs');
-                    let finalUsage = undefined;
+                    // Si NO fue cancelación de usuario, cerrar la misión como fallida en el servidor
                     try {
-                        const ctxDir = process.env.CONTEXT_DIR;
-                        if (fs.existsSync(ctxDir)) {
-                            const files = fs.readdirSync(ctxDir);
-                            const logFiles = files.filter(f => f.startsWith('agent-log-') && f.endsWith('.json')).sort();
-                            if (logFiles.length > 0) {
-                                const lastLog = path.join(ctxDir, logFiles[logFiles.length - 1]);
-                                const logData = JSON.parse(fs.readFileSync(lastLog, 'utf8'));
-                                finalUsage = logData.usage;
+                        let finalUsage = undefined;
+                        let failReason = "timeout_or_crash";
+                        try {
+                            const ctxDir = process.env.CONTEXT_DIR;
+                            if (fs.existsSync(ctxDir)) {
+                                const files = fs.readdirSync(ctxDir);
+                                const logFiles = files.filter(f => f.startsWith('agent-log-') && f.endsWith('.json')).sort();
+                                if (logFiles.length > 0) {
+                                    const lastLog = path.join(ctxDir, logFiles[logFiles.length - 1]);
+                                    const logData = JSON.parse(fs.readFileSync(lastLog, 'utf8'));
+                                    finalUsage = logData.usage;
+                                    failReason = logData.fail_reason || failReason;
+                                }
                             }
-                        }
-                    } catch(e) {}
-                    await endMission(mission.mission_id, 'failed', finalUsage);
-                } catch { }
+                        } catch(e) {}
+
+                        // ── Upload Evidence ──
+                        const { endMission, getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
+                        const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
+
+                        try {
+                            const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
+                            if (sasData && sasData.sasUrl) {
+                                if (!process.argv.includes('--debug')) s.start('☁️  Uploading evidence to Azure...');
+                                const reportsDir = process.env.REPORTS_DIR || path.join(ORIGINAL_CWD, 'tests-report');
+
+                                await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
+
+                                await uploadEvidence(reportsDir, sasData.sasUrl, sasData.basePath);
+                                if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Evidence uploaded successfully.'));
+                            }
+                        } catch (e) {}
+
+                        await endMission(mission.mission_id, 'failed', finalUsage, failReason);
+                    } catch { }
+                }
             } finally {
+                // Si fue cancelación de usuario, dar un breve margen para que el cancelHandler
+                // async (endMission, escritura de log) termine antes de generar el reporte.
+                if (userCanceledMission) {
+                    await new Promise(r => setTimeout(r, 800));
+                }
+
                 const sRep = spinner();
                 sRep.start('📊 Generating report...');
                 await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });

package/scripts/init.mjs

@@ -143,8 +143,12 @@ async function main() {
                 401: '❌ Invalid API Key. Please check your key and try again.',
                 403: `❌ Authentication Failed (HTTP 403). Server says: ${errText.slice(0, 150)}`,
             };
-            s.stop(chalk.red(errorMap[res.status] || `❌ Server error (HTTP ${res.status}): ${errText.slice(0, 150)}`));
-            process.exit(1);
+            const msg = errorMap[res.status] || `❌ Server error (HTTP ${res.status}): ${errText.slice(0, 150)}`;
+            s.stop(chalk.red(msg));
+            console.log(chalk.yellow('\n   Press Enter to return to menu...'));
+            // Salida limpia (código 0) para que el menú padre no interprete esto como crash
+            await new Promise(r => setTimeout(r, 3000));
+            process.exit(0);
         }
 
         const data = await res.json();
@@ -162,7 +166,8 @@ async function main() {
     } 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);
+        await new Promise(r => setTimeout(r, 3000));
+        process.exit(0);
     }
 
     // ── Step 3: Project details ──

package/src/EvidenceUploader.mjs

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ContainerClient } from '@azure/storage-blob';
+import mime from 'mime-types';
+
+/**
+ * Subes la evidencia de prueba iterativamente a Azure Blob Storage usando una URL de SAS.
+ * @param {string} reportsDir Directorio local de reportes.
+ * @param {string} sasUrl URL de SAS para el ContainerClient.
+ * @param {string} basePath Path base dentro del contenedor de Azure.
+ */
+export async function uploadEvidence(reportsDir, sasUrl, basePath) {
+    if (!fs.existsSync(reportsDir)) return;
+
+    const containerClient = new ContainerClient(sasUrl);
+
+    async function walkAndUpload(currentDir, relativePath = '') {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        const uploadPromises = [];
+
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const entryRelativePath = path.posix.join(relativePath, entry.name);
+
+            if (entry.isDirectory()) {
+                uploadPromises.push(walkAndUpload(fullPath, entryRelativePath));
+            } else {
+                // Blob path en Azure: basePath/ruta_relativa_del_archivo
+                const blobPath = `${basePath}/${entryRelativePath}`;
+                const blockBlobClient = containerClient.getBlockBlobClient(blobPath);
+                
+                const contentType = mime.lookup(entry.name) || 'application/octet-stream';
+
+                uploadPromises.push(
+                    blockBlobClient.uploadFile(fullPath, {
+                        blobHTTPHeaders: { blobContentType: contentType }
+                    })
+                );
+            }
+        }
+        await Promise.all(uploadPromises);
+    }
+
+    await walkAndUpload(reportsDir);
+}

package/src/KnowledgeService.ts

@@ -41,12 +41,14 @@ export class KnowledgeService {
     private apiBase: string;
     private apiKey: string;
     private projectId: string | null = null;
+    private orgId: string | null = null;
 
     private constructor() {
         // API URL is internal-only, loaded from the tool's .env via dotenv
         this.apiBase = process.env.ARCALITY_API_URL || 'https://arcalityqadev.arcadial.lat';
         this.apiKey = process.env.ARCALITY_API_KEY || '';
         this.projectId = process.env.ARCALITY_PROJECT_ID || null;
+        this.orgId = process.env.ARCALITY_ORG_ID || null;
     }
 
     /**
@@ -140,7 +142,7 @@ export class KnowledgeService {
             if (res.status === 200) {
                 const data = await res.json();
                 if (data.status === 'skipped_duplicate_dom') {
-                   // console.log(chalk.gray(`[Knowledge] Ingesta omitida (Duplicado).`));
+                    // console.log(chalk.gray(`[Knowledge] Ingesta omitida (Duplicado).`));
                 } else {
                     console.log(chalk.cyan(`[Knowledge] Ingesta exitosa (Project: ${payload.project_id})`));
                 }
@@ -158,10 +160,13 @@ export class KnowledgeService {
         if (!pid || pid === 'undefined') return null;
         try {
             const pathUrl = new URL(url).pathname;
-            const res = await this.fetchWithTimeout(
-                `${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`,
-                { headers: { 'x-api-key': this.apiKey } }
-            );
+            let contextUrl = `${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`;
+            if (this.orgId) {
+                contextUrl += `&organization_id=${this.orgId}`;
+            }
+            const res = await this.fetchWithTimeout(contextUrl, {
+                headers: { 'x-api-key': this.apiKey }
+            });
             if (!res.ok) return null;
             return await res.json();
         } catch (e: any) {
@@ -185,6 +190,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     rule_type: "UI_UX", // Default según especificación
                     title,
@@ -210,6 +216,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     field_identifier: identifier,
                     field_type: type,
@@ -235,6 +242,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     doc_type: docType,
                     title,

package/src/arcalityClient.mjs

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { getApiKey, getApiUrl, CONFIG_DIR } from './configLoader.mjs';
 
 // ── Backend config (internal, not user-configurable) ──
-const DAILY_MISSION_LIMIT = 50;
+const DAILY_MISSION_LIMIT = 35;
 const USAGE_FILE = path.join(CONFIG_DIR, 'usage.json');
 
 // ═══════════════════════════════════════════════════════
@@ -128,22 +128,31 @@ export async function validateApiKey() {
     // ── LIVE mode: Backend available ──
     if (apiBase) {
         try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
             const res = await fetch(`${apiBase}/api/v1/auth/validate`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     'x-api-key': key
-                }
+                },
+                signal: controller.signal
             });
+            clearTimeout(timeout);
 
             if (res.status === 401) return { valid: false, error: 'invalid_api_key', mode: 'live' };
             if (res.status === 403) return { valid: false, error: 'plan_expired', mode: 'live' };
             if (!res.ok) return { valid: false, error: 'server_error', mode: 'live' };
 
             const data = await res.json();
+            if (process.env.DEBUG || process.argv.includes('--debug')) {
+                console.log(`[DEBUG] Auth validation response keys:`, Object.keys(data));
+                console.log(`[DEBUG] Auth validation response:`, JSON.stringify(data, null, 2));
+            }
             return { ...data, valid: true, mode: 'live' };
-        } catch {
-            console.warn('⚠️  Backend not available, using local mode');
+        } catch (e) {
+            const reason = e?.name === 'AbortError' ? 'timeout (5s)' : (e?.message || 'unknown');
+            console.warn(`⚠️  Backend not available (${apiBase}): ${reason}. Using local mode.`);
         }
     }
 
@@ -175,6 +184,8 @@ export async function startMission(prompt, targetUrl) {
         try {
             const projectId = process.env.ARCALITY_PROJECT_ID || loadArcalityConfig()?.projectId;
 
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
             const res = await fetch(`${apiBase}/api/v1/missions/start`, {
                 method: 'POST',
                 headers: {
@@ -186,8 +197,10 @@ export async function startMission(prompt, targetUrl) {
                     prompt_hash: simpleHash(prompt),
                     target_url: targetUrl,
                     project_id: projectId || undefined,
-                })
+                }),
+                signal: controller.signal
             });
+            clearTimeout(timeout);
 
             if (res.status === 429) {
                 const data = await res.json();
@@ -196,8 +209,9 @@ export async function startMission(prompt, targetUrl) {
             if (!res.ok) return { allowed: false, error: 'server_error' };
 
             return { allowed: true, ...(await res.json()) };
-        } catch {
-            // Fallback to mock if backend is down
+        } catch (e) {
+            const reason = e?.name === 'AbortError' ? 'timeout (5s)' : (e?.message || 'unknown');
+            console.warn(`⚠️  startMission failed (${apiBase}): ${reason}. Falling back to mock mode.`);
         }
     }
 
@@ -236,7 +250,7 @@ export async function startMission(prompt, targetUrl) {
  * @param {'success'|'failed'|'cancelled'} result
  * @param {object} usage - Optional usage statistics directly from the AI
  */
-export async function endMission(missionId, result, usage = null) {
+export async function endMission(missionId, result, usage = null, failReason = null) {
     const apiBase = getEffectiveApiBase();
     if (!apiBase || !missionId) return { ok: true };
 
@@ -248,7 +262,7 @@ export async function endMission(missionId, result, usage = null) {
                 'Content-Type': 'application/json',
                 'x-api-key': key
             },
-            body: JSON.stringify({ result, usage })
+            body: JSON.stringify({ result, usage, failReason })
         });
     } catch { }
     return { ok: true };
@@ -266,3 +280,33 @@ function simpleHash(str) {
     }
     return 'ph_' + Math.abs(hash).toString(36);
 }
+
+/**
+ * Obtiene el Token SAS y el path base para subir evidencias.
+ * @param {string} missionId
+ * @param {string} projectId
+ */
+export async function getEvidenceSasToken(missionId, projectId) {
+    const apiBase = getEffectiveApiBase();
+    if (!apiBase || !missionId || !projectId) return null;
+
+    const key = getEffectiveApiKey();
+    if (!key) return null;
+
+    try {
+        const res = await fetch(`${apiBase}/api/v1/missions/${missionId}/evidence/sas`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${key}`
+            },
+            body: JSON.stringify({ projectId })
+        });
+
+        if (!res.ok) return null;
+        
+        return await res.json();
+    } catch {
+        return null;
+    }
+}

package/src/configLoader.mjs

@@ -18,7 +18,8 @@ export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
  * @returns {string}
  */
 export function getApiUrl() {
-    return process.env.ARCALITY_API_URL || 'https://arcalityqadev.arcadial.lat';
+    // return 'https://arcalityqadev.arcadial.lat';
+    return 'https://arcalityqadev.arcadial.lat';
 }
 
 /**