@arcadialdev/arcality 2.3.4 → 2.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcadialdev/arcality",
-  "version": "2.3.4",
+  "version": "2.4.20",
   "description": "AI-powered QA testing tool — Autonomous web testing agent by Arcadial",
   "main": "index.js",
   "scripts": {

package/scripts/gen-and-run.mjs

@@ -9,7 +9,8 @@ import path from "node:path";
 import { createRequire } from 'node:module';
 import { spawn, exec } from "node:child_process";
 import chalk from "chalk";
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
+const require = createRequire(import.meta.url);
 import figlet from "figlet";
 import { intro, outro, select, text, spinner, note, isCancel, cancel } from '@clack/prompts';
 import { load as loadYaml } from 'js-yaml';
@@ -303,21 +304,34 @@ function sanitizeFilename(name, fallback) {
 }
 
 function run(cmd, args, options = {}) {
+    const isDebug = process.argv.includes('--debug');
+    const cwd = options.cwd || process.cwd();
+
     return new Promise((resolve, reject) => {
+        // NODE_PATH: let Node resolve modules from both the arcality package and user's project
         const appNodeModules = path.join(PROJECT_ROOT, 'node_modules');
+        const userNodeModules = path.join(ORIGINAL_CWD, 'node_modules');
         const existingNodePath = process.env.NODE_PATH || '';
-        const newNodePath = existingNodePath ? `${appNodeModules}${path.delimiter}${existingNodePath}` : appNodeModules;
+        const newNodePath = [appNodeModules, userNodeModules, existingNodePath].filter(Boolean).join(path.delimiter);
+
+        const env = { ...options.env || process.env, NODE_PATH: newNodePath };
+        if (isDebug) console.log(chalk.gray(`\n[DEBUG] CWD: ${cwd}`));
+        if (isDebug) console.log(chalk.gray(`[DEBUG] Running: ${cmd} ${args.join(' ')}`));
 
+        // Use standard cross-platform spawn. When shell is false, Node's child_process 
+        // properly wraps arguments with spaces in quotes natively for CreateProcessW on Windows.
         const p = spawn(cmd, args, {
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: false,  // IMPORTANT: shell:false prevents Windows CMD from splitting paths with spaces
-            windowsHide: true,
-            env: { ...options.env || process.env, NODE_PATH: newNodePath },
+            stdio: isDebug ? ['inherit', 'inherit', 'inherit'] : ['ignore', 'pipe', 'pipe'],
+            shell: false,
+            cwd,
+            env,
         });
 
         let outputBuffer = '';
-        p.stdout.on('data', (data) => {
+        const handleData = (data) => {
             const str = data.toString();
+            outputBuffer += str;
+
             if (str.includes('>>ARCALITY_STATUS>>')) {
                 const lines = str.split('\n');
                 for (const line of lines) {
@@ -331,15 +345,19 @@ function run(cmd, args, options = {}) {
             } else {
                 process.stdout.write(data);
             }
-            outputBuffer += str;
-        });
+        };
 
-        p.stderr.on('data', (data) => {
-            process.stderr.write(data);
-            outputBuffer += data.toString();
-        });
+        if (!isDebug && p.stdout) {
+            p.stdout.on('data', handleData);
+        }
+        if (!isDebug && p.stderr) {
+            p.stderr.on('data', (data) => {
+                process.stderr.write(data);
+                outputBuffer += data.toString();
+            });
+        }
 
-        p.on("exit", (code) => {
+        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 });
@@ -347,7 +365,15 @@ function run(cmd, args, options = {}) {
             } catch (e) { }
 
             if (code === 0) resolve();
-            else reject(new Error(`Command failed (${code}): ${cmd} ${args.join(" ")}`));
+            else {
+                if (isDebug) console.error(chalk.red(`\n[DEBUG] Process exited with code ${code}`));
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+
+        p.on('error', (err) => {
+            if (isDebug) console.error(chalk.red(`\n[DEBUG] Process failed to spawn: ${err.message}`));
+            reject(err);
         });
     });
 }
@@ -398,6 +424,8 @@ async function main() {
     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 debugIndex = argv.findIndex(a => a === '--debug');
+    if (debugIndex !== -1) { argv.splice(debugIndex, 1); } // Handled by run() naturally now
 
     const promptArg = argv.join(" ").trim();
     let firstRun = true;
@@ -575,7 +603,10 @@ async function main() {
         }
 
         if (agentMode) {
-            const dotEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+            // Load environment from BOTH the user's project and the library's root
+            const userDotEnv = parseDotEnvFile(path.join(ORIGINAL_CWD, '.env'));
+            const libDotEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+            const dotEnv = { ...userDotEnv, ...libDotEnv }; 
 
             // ── API Key and Quota Validation ──
             const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
@@ -688,14 +719,21 @@ async function main() {
             }
 
             const s = spinner();
-            s.start(`🤖 [AGENT MODE] Starting mission: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit} today)`)}`);
+            if (!process.argv.includes('--debug')) {
+                s.start(`🤖 [AGENT MODE] Starting mission: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit} today)`)}`);
+            } else {
+                console.log(chalk.cyan(`\n🤖 [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
+            // 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().
             const mergedEnv = {
                 ...dotEnv,
                 ...process.env,
+                ARCALITY_API_URL: getApiUrl(),          // Internal URL — always injected explicitly
                 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,
@@ -712,33 +750,50 @@ async function main() {
                 console.log(chalk.gray(`\n>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
             }
 
-            // Resolve playwright CLI using Node's module resolution algorithm.
-            // This handles BOTH cases:
-            //   - Global install: playwright is inside arcality's own node_modules
-            //   - Local install:  playwright is hoisted to the project's root node_modules
+            // ── Resolve execution paths ──
+            // tsx and playwright are HOISTED to ORIGINAL_CWD/node_modules when installed via npm.
+            // We run from ORIGINAL_CWD so relative paths for playwright work.
+            // For the test file and config (inside the arcality package), we use absolute paths.
+            //
+            // KEY: tsx loader uses file:// URL (pathToFileURL) so spaces encode as %20 — no quoting needed.
+
+            const testFile   = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.spec.ts');
+            const configFile = path.join(PROJECT_ROOT, 'playwright.config.js');
+
+            // Resolve playwright CLI relative to PROJECT_ROOT exactly as Node handles module resolution.
+            // This prevents the "did not expect test() to be called here" singleton duplication error.
             let playwrightCli;
             try {
-                const arcalityRequire = createRequire(path.join(PROJECT_ROOT, 'package.json'));
-                playwrightCli = arcalityRequire.resolve('playwright/cli');
-            } catch {
-                // Fallback: try local hoisted path (project_root/../../playwright)
-                const hoistedPath = path.join(PROJECT_ROOT, '..', '..', 'playwright', 'cli.js');
-                if (fs.existsSync(hoistedPath)) {
-                    playwrightCli = hoistedPath;
-                } else {
-                    playwrightCli = path.join(PROJECT_ROOT, 'node_modules', 'playwright', 'cli.js');
+                // Find the core @playwright/test that the local project uses
+                const testRunnerPath = require.resolve('@playwright/test', { paths: [PROJECT_ROOT] });
+                // Target the cli.js file strictly inside its parallel playwright dependency
+                playwrightCli = path.join(testRunnerPath, '..', '..', '..', 'playwright', 'cli.js');
+                if (!fs.existsSync(playwrightCli)) {
+                    throw new Error(`CLI not found exactly at: ${playwrightCli}`);
                 }
+            } catch (e) {
+                console.error(chalk.red('\n[FATAL] Playwright core not found! Make sure playwright is properly installed.'));
+                console.error(chalk.red(e.message));
+                process.exit(1);
             }
-            const configFile = path.join(PROJECT_ROOT, 'playwright.config.js');
+
             try {
-                // IMPORTANT: Playwright's internal `.ts` transpiler intentionally ignores everything inside `node_modules`.
-                // Because Arcality tests run from inside `node_modules/@arcadialdev/arcality`, Playwright refuses to compile them.
-                // We use `--import tsx` to force Node to transpile TypeScript globally regardless of path.
-                await run("node", ["--import", "tsx", playwrightCli, "test", path.join(PROJECT_ROOT, "tests/_helpers/agentic-runner.spec.ts"), "--headed", `--config=${configFile}`], {
+                // By switching cwd to PROJECT_ROOT, playwright's internal regex test match 
+                // perfectly matches relative paths without breaking on Windows backslashes.
+                await run('node', [
+                    '--no-warnings',
+                    playwrightCli,
+                    'test',
+                    'tests/_helpers/agentic-runner.spec.ts', // RELATIVE path prevents regex errors
+                    '--headed',
+                    '--config', 'playwright.config.js'
+                ], {
+                    cwd: PROJECT_ROOT,    // Run from the tool's true root!
                     env: mergedEnv,
-                    onStatus: (msg) => s.message(msg)
+                    onStatus: (msg) => { if (!process.argv.includes('--debug')) s.message(msg); else console.log(chalk.gray(`>> Status: ${msg}`)); }
                 });
-                s.stop(chalk.green('✅ Mission completed successfully.'));
+                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');
@@ -792,7 +847,11 @@ async function main() {
                     }
                 }
             } catch (e) {
-                s.stop(chalk.red('❌ Mission could not be completed.'));
+                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 {

package/src/KnowledgeService.ts

@@ -49,6 +49,23 @@ export class KnowledgeService {
         this.projectId = process.env.ARCALITY_PROJECT_ID || null;
     }
 
+    /**
+     * Fetch wrapper with a 10-second timeout to prevent hanging.
+     * All KnowledgeService calls are telemetry/secondary — they must NEVER block the agent.
+     */
+    private async fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = 10000): Promise<Response> {
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, { ...options, signal: controller.signal });
+            clearTimeout(id);
+            return res;
+        } catch (err: any) {
+            clearTimeout(id);
+            throw err;
+        }
+    }
+
     public static getInstance(): KnowledgeService {
         if (!KnowledgeService.instance) {
             KnowledgeService.instance = new KnowledgeService();
@@ -72,7 +89,7 @@ export class KnowledgeService {
      */
     public async getProjects(): Promise<ProjectDto[]> {
         try {
-            const res = await fetch(`${this.apiBase}/api/v1/projects`, {
+            const res = await this.fetchWithTimeout(`${this.apiBase}/api/v1/projects`, {
                 headers: { 'x-api-key': this.apiKey }
             });
             if (!res.ok) return [];
@@ -86,7 +103,7 @@ export class KnowledgeService {
 
     public async createProject(name: string, baseUrl: string): Promise<ProjectDto | null> {
         try {
-            const res = await fetch(`${this.apiBase}/api/v1/projects`, {
+            const res = await this.fetchWithTimeout(`${this.apiBase}/api/v1/projects`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -112,7 +129,7 @@ export class KnowledgeService {
         }
 
         try {
-            const res = await fetch(`${this.apiBase}/api/v1/portal/ingest`, {
+            const res = await this.fetchWithTimeout(`${this.apiBase}/api/v1/portal/ingest`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -141,10 +158,10 @@ export class KnowledgeService {
         if (!pid || pid === 'undefined') return null;
         try {
             const pathUrl = new URL(url).pathname;
-            // Para queries de GET solemos usar snake_case si el server es estricto
-            const res = await fetch(`${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`, {
-                headers: { 'x-api-key': this.apiKey }
-            });
+            const res = await this.fetchWithTimeout(
+                `${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`,
+                { headers: { 'x-api-key': this.apiKey } }
+            );
             if (!res.ok) return null;
             return await res.json();
         } catch (e: any) {

package/src/configLoader.mjs

@@ -167,6 +167,12 @@ export function setupProcessEnv() {
             process.env.LOGIN_PASSWORD = localConfig.auth.password;
         }
     }
+    // SIEMPRE garantizar que la URL interna de la API esté en process.env.
+    // Esta URL es interna de la herramienta, no configurable por el usuario.
+    // Proviene del .env de la librería o usa el valor por defecto.
+    if (!process.env.ARCALITY_API_URL) {
+        process.env.ARCALITY_API_URL = 'https://arcalityqadev.arcadial.lat';
+    }
 }
 
 /**

package/tests/_helpers/ArcalityReporter.js

@@ -53,9 +53,33 @@ class ArcalityReporter {
             }
         });
 
+        if (result.status !== 'passed') {
+            console.log(`\n⚠️ [TEST END] ${test.title} ended with status: ${result.status}`);
+            if (result.error) console.log(`Error: ${result.error?.message || result.error?.stack || 'Unknown'}`);
+        }
+
         this.results.push({ test, result, stepsHtml, attachments: processedAttachments });
     }
 
+    onTestBegin(test) {
+        console.log(`▶️ [TEST BEGIN] ${test.title}`);
+    }
+
+    onStdErr(chunk, test, result) {
+        console.error(`[STDERR] ${chunk.toString()}`);
+    }
+
+    onStdOut(chunk, test, result) {
+        console.log(`[STDOUT] ${chunk.toString()}`);
+    }
+
+    onError(error) {
+        console.log(`\n❌ [FATAL GLOBAL ERROR]`);
+        console.log(error.message || error.stack || JSON.stringify(error));
+        if (error.stack) console.log(error.stack);
+        if (error.value) console.log(error.value);
+    }
+
     async onEnd(result) {
         this.totalDuration = result.duration;
         const htmlContent = this.generateHtml();

package/tests/_helpers/ArcalityReporter.ts

@@ -66,6 +66,14 @@ class ArcalityReporter implements Reporter {
             }
         });
 
+        if (result.status === 'failed' || result.error) {
+            console.log(`\n❌ [TEST ENGINE FAILURE] ${test.title} failed:`);
+            console.log(`${result.error?.message || result.error?.stack || 'Unknown error'}\n`);
+            if (result.error?.stack) {
+                console.log(result.error.stack);
+            }
+        }
+
         this.results.push({ test, result, stepsHtml, attachments: processedAttachments });
     }
 

package/tests/_helpers/ai-agent-helper.ts

@@ -540,12 +540,13 @@ ${best.steps.slice(0, 15).map((s: any) => `  - ${s}`).join('\n')}
     }
 
     async askIA(prompt: string, history: string[] = []): Promise<AgentAction> {
-        // MODO BRIDGE: Si existe una URL de portal, delegamos la decisión al servidor (SaaS)
-        if (process.env.ARCALITY_PORTAL_URL) {
-            return this.askBridge(prompt, history);
-        }
+        // El modo proxy (ARCALITY_API_URL) está integrado en el bucle de fetch de abajo.
+        // Si ARCALITY_API_URL está definido, se enruta automáticamente a /api/v1/ai/proxy.
+        // Si no, requiere ANTHROPIC_API_KEY para llamada directa.
 
-        if (!process.env.ANTHROPIC_API_KEY) throw new Error("ANTHROPIC_API_KEY missing");
+        if (!process.env.ARCALITY_API_URL && !process.env.ANTHROPIC_API_KEY) {
+            throw new Error("ANTHROPIC_API_KEY missing and ARCALITY_API_URL not configured");
+        }
 
         const state = await this.getPageState();
         const screenshot = await this.page.screenshot({ type: 'png' });
@@ -827,6 +828,9 @@ ${history.slice(-25).join('\n') || 'None'}`
                     ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy`
                     : "https://api.anthropic.com/v1/messages";
 
+                // Log the endpoint being called on every turn so we can debug connectivity
+                console.log(`>>ARCALITY_STATUS>> 📡 Llamando a: ${endpointUrl} (turno ${turn + 1})`);
+
                 const headers: Record<string, string> = {
                     "Content-Type": "application/json"
                 };
@@ -838,26 +842,43 @@ ${history.slice(-25).join('\n') || 'None'}`
                     headers["anthropic-version"] = "2023-06-01";
                 }
 
-                response = await fetch(endpointUrl, {
-                    method: "POST",
-                    headers,
-                    body: JSON.stringify({
-                        model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
-                        max_tokens: 4096,
-                        system: systemPromptBlocks,
-                        tools: rawTools.map(t => ({
-                            name: t.name,
-                            description: t.description,
-                            input_schema: (t as any).parameters || (t as any).input_schema
-                        })),
-                        messages: anthropicMessages,
-                        temperature: 0.2
-                    })
-                });
+                // AbortController: 90s timeout to prevent silent hangs
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 90000);
+
+                try {
+                    response = await fetch(endpointUrl, {
+                        method: "POST",
+                        headers,
+                        signal: controller.signal,
+                        body: JSON.stringify({
+                            model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
+                            max_tokens: 4096,
+                            system: systemPromptBlocks,
+                            tools: rawTools.map(t => ({
+                                name: t.name,
+                                description: t.description,
+                                input_schema: (t as any).parameters || (t as any).input_schema
+                            })),
+                            messages: anthropicMessages,
+                            temperature: 0.2
+                        })
+                    });
+                } catch (fetchErr: any) {
+                    clearTimeout(timeoutId);
+                    if (fetchErr.name === 'AbortError') {
+                        throw new Error(`Arcality Brain Timeout: No response from ${endpointUrl} after 90s`);
+                    }
+                    throw new Error(`Arcality Brain Network Error: ${fetchErr.message}`);
+                }
+                clearTimeout(timeoutId);
 
                 if (response.ok) break;
 
                 const errorText = await response.text();
+                // Always log the error body so the developer can see what went wrong
+                console.log(`>>ARCALITY_STATUS>> ❌ API Error ${response.status}: ${errorText.substring(0, 500)}`);
+
                 const isTransient = response.status === 529 || response.status === 429 || response.status === 503;
 
                 if (isTransient && retryCount < maxRetries) {
@@ -868,7 +889,7 @@ ${history.slice(-25).join('\n') || 'None'}`
                     continue;
                 }
 
-                throw new Error(`Arcality Brain Error: ${errorText}`);
+                throw new Error(`Arcality Brain Error ${response.status}: ${errorText}`);
             }
 
             const data: any = await response.json();
@@ -1445,63 +1466,7 @@ ${history.slice(-25).join('\n') || 'None'}`
     /**
      * MODO BRIDGE: Envía la percepción de la CLI hacia el Portal Web (SaaS)
      * para que el servidor decida la acción usando su propia infraestructura e IP.
-     */
-    private async askBridge(prompt: string, history: string[] = []): Promise<AgentAction> {
-        console.log(`>>ARCALITY_STATUS>> 🌐 Conectando con el cerebro de Arcality (Modo SaaS)...`);
-
-        const state = await this.getPageState();
-        const screenshot = await this.page.screenshot({ type: 'png' });
-
-        // Payload enriquecido para el portal
-        const payload = {
-            mission: prompt,
-            history: history,
-            percept: {
-                url: state.url,
-                title: state.title,
-                components: state.components,
-                screenshot: screenshot.toString('base64'),
-                logs: this.logs
-            },
-            context: {
-                version: "1.0.1",
-                model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
-                config: process.env.ACTIVE_CONFIG || "Default"
-            }
-        };
-
-        try {
-            const baseUrl = process.env.ARCALITY_PORTAL_URL || "";
-            const url = baseUrl.endsWith('/')
-                ? baseUrl + 'api/v1/decide'
-                : baseUrl + '/api/v1/decide';
-
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-arcality-cli-version': '1.0.1'
-                },
-                body: JSON.stringify(payload)
-            });
-
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`SaaS Bridge Error (${response.status}): ${errorText}`);
-            }
-
-            const decision = await response.json() as AgentAction;
-            return decision;
-
-        } catch (err: any) {
-            console.error(chalk.red(`\n❌ Error en el Bridge de Arcality: ${err.message}`));
-            console.log(chalk.yellow(`\n⚠️ Reintentando modo local (Direct Claude)...`));
-
-            // Fallback al modo local si el bridge falla por red o configuración
-            delete process.env.ARCALITY_PORTAL_URL;
-            return this.askIA(prompt, history);
-        }
-    }
+    // askBridge eliminado — proxy mode ahora está integrado directamente en askIA.
 
     /**
      * QA Skill: Summarizes the mission execution into a clean, human-friendly English YAML format.