ai-extension-preview 0.1.17 → 0.1.18

package/dist/plugins/ServerPlugin.js

@@ -30,6 +30,28 @@ const ServerPlugin = {
                 res.end();
                 return;
             }
+            if (req.url === '/logs') {
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Access-Control-Allow-Origin': '*'
+                });
+                const sendLog = (data) => {
+                    res.write(`data: ${JSON.stringify(data)}\n\n`);
+                };
+                // Subscribe to browser logs
+                const unsubscribe = ctx.events.on('browser:log', sendLog);
+                // Heartbeat to keep connection alive
+                const interval = setInterval(() => {
+                    res.write(':\n\n');
+                }, 15000);
+                req.on('close', () => {
+                    unsubscribe();
+                    clearInterval(interval);
+                });
+                return;
+            }
             if (req.url === '/status') {
                 const currentJobId = ctx.config.jobId;
                 res.writeHead(200, { 'Content-Type': 'application/json' });

package/dist/plugins/browser/BrowserManagerPlugin.js

@@ -1,6 +1,8 @@
 import path from 'path';
 import fs from 'fs-extra';
-import { findExtensionRoot, validateExtension } from '../../utils/browserUtils.js';
+import { findExtensionRoot, validateExtension, getWSLTempPath } from '../../utils/browserUtils.js';
+import puppeteer from 'puppeteer-core';
+import os from 'os';
 const BrowserManagerPlugin = {
     name: 'browser-manager',
     version: '1.0.0',
@@ -12,10 +14,32 @@ const BrowserManagerPlugin = {
             const DIST_DIR = path.join(config.workDir, 'dist');
             const isWSL = fs.existsSync('/mnt/c');
             const isWin = process.platform === 'win32';
-            const STAGING_DIR = isWSL
-                ? '/mnt/c/Temp/ai-ext-preview'
-                : (isWin ? 'C:\\Temp\\ai-ext-preview' : path.join(config.workDir, '../staging'));
-            return { DIST_DIR, STAGING_DIR };
+            let STAGING_DIR = '';
+            let WIN_STAGING_DIR = '';
+            if (isWSL) {
+                const wslPaths = getWSLTempPath();
+                if (wslPaths) {
+                    STAGING_DIR = path.join(wslPaths.wsl, 'ai-ext-preview');
+                    WIN_STAGING_DIR = path.join(wslPaths.win, 'ai-ext-preview');
+                }
+                else {
+                    // Fallback
+                    STAGING_DIR = '/mnt/c/Temp/ai-ext-preview';
+                    WIN_STAGING_DIR = 'C:\\Temp\\ai-ext-preview';
+                }
+            }
+            else if (isWin) {
+                // Native Windows (Git Bash, Command Prompt, PowerShell)
+                // Use os.tmpdir() which resolves to %TEMP%
+                const tempDir = os.tmpdir();
+                STAGING_DIR = path.join(tempDir, 'ai-ext-preview');
+                WIN_STAGING_DIR = STAGING_DIR; // Node handles paths well, but we can verify later
+            }
+            else {
+                // Linux / Mac (Native)
+                STAGING_DIR = path.join(config.workDir, '../staging');
+            }
+            return { DIST_DIR, STAGING_DIR, WIN_STAGING_DIR };
         };
         // --- SYNC FUNCTION ---
         const syncToStaging = async () => {
@@ -35,7 +59,7 @@ const BrowserManagerPlugin = {
             }
         };
         const launchBrowser = async () => {
-            const { STAGING_DIR } = getPaths();
+            const { STAGING_DIR, WIN_STAGING_DIR } = getPaths();
             // Resolve proper root AFTER sync
             const extensionRoot = findExtensionRoot(STAGING_DIR) || STAGING_DIR;
             // 1. Static Validation
@@ -46,34 +70,121 @@ const BrowserManagerPlugin = {
             else if (extensionRoot !== STAGING_DIR) {
                 await ctx.logger.info(`Detected nested extension at: ${path.basename(extensionRoot)}`);
             }
-            // 2. Runtime Verification (Diagnostic) - SKIPPED FOR PERFORMANCE
-            // The SandboxRunner spins up a separate headless chrome which is slow and prone to WSL networking issues.
-            // Since we have static analysis in the backend, we skip this blocking step to give the user immediate feedback.
-            /*
-            await ctx.actions.runAction('core:log', { level: 'info', message: 'Running diagnostic verification...' });
-            const diagResult = await SandboxRunner.validateExtensionRuntime(extensionRoot);
-
-            if (diagResult.success) {
-                await ctx.actions.runAction('core:log', { level: 'info', message: '✅ Diagnostic Verification Passed.' });
-            } else {
-                await ctx.actions.runAction('core:log', { level: 'error', message: `❌ Diagnostic Verification Failed: ${diagResult.error}` });
-            }
-            */
             // Delegate Launch
-            // We pass the filesystem path (STAGING_DIR or extensionRoot)
-            // The specific Launcher plugin handles environment specific path verification/conversion
             await ctx.actions.runAction('launcher:launch', {
                 extensionPath: extensionRoot,
-                stagingDir: STAGING_DIR
+                stagingDir: STAGING_DIR,
+                winStagingDir: WIN_STAGING_DIR
             });
         };
         let isInitialized = false;
+        let browserConnection = null;
+        const getHostIp = () => {
+            // In WSL2, the host IP is in /etc/resolv.conf
+            try {
+                if (fs.existsSync('/etc/resolv.conf')) {
+                    const content = fs.readFileSync('/etc/resolv.conf', 'utf-8');
+                    const match = content.match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+                    if (match)
+                        return match[1];
+                }
+            }
+            catch { }
+            return null;
+        };
+        const connectToBrowser = async () => {
+            // Retry connection for 30 seconds
+            const maxRetries = 60;
+            const hostIp = getHostIp();
+            const port = 9222;
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    try {
+                        // Strategy 1: Host IP
+                        if (hostIp) {
+                            browserConnection = await puppeteer.connect({
+                                browserURL: `http://${hostIp}:${port}`,
+                                defaultViewport: null
+                            });
+                        }
+                        else {
+                            throw new Error('No Host IP');
+                        }
+                    }
+                    catch (err1) {
+                        try {
+                            // Strategy 2: 0.0.0.0 (Requested by User)
+                            browserConnection = await puppeteer.connect({
+                                browserURL: `http://0.0.0.0:${port}`,
+                                defaultViewport: null
+                            });
+                        }
+                        catch (err2) {
+                            try {
+                                // Strategy 3: 127.0.0.1
+                                browserConnection = await puppeteer.connect({
+                                    browserURL: `http://127.0.0.1:${port}`,
+                                    defaultViewport: null
+                                });
+                            }
+                            catch (err3) {
+                                // Strategy 4: Localhost
+                                try {
+                                    browserConnection = await puppeteer.connect({
+                                        browserURL: `http://localhost:${port}`,
+                                        defaultViewport: null
+                                    });
+                                }
+                                catch (err4) {
+                                    throw new Error(`Host(${hostIp}): ${err1.message}, 0.0.0.0: ${err2.message}, IP: ${err3.message}, Localhost: ${err4.message}`);
+                                }
+                            }
+                        }
+                    }
+                    ctx.logger.info('[LogCapture] Connected to browser CDP');
+                    const attachToPage = async (page) => {
+                        page.on('console', (msg) => {
+                            const type = msg.type();
+                            const text = msg.text();
+                            ctx.events.emit('browser:log', {
+                                level: type === 'warning' ? 'warn' : type,
+                                message: text,
+                                timestamp: new Date().toISOString()
+                            });
+                        });
+                        page.on('pageerror', (err) => {
+                            ctx.events.emit('browser:log', {
+                                level: 'error',
+                                message: `[Runtime Error] ${err.toString()}`,
+                                timestamp: new Date().toISOString()
+                            });
+                        });
+                    };
+                    const pages = await browserConnection.pages();
+                    pages.forEach(attachToPage);
+                    browserConnection.on('targetcreated', async (target) => {
+                        const page = await target.page();
+                        if (page)
+                            attachToPage(page);
+                    });
+                    return;
+                }
+                catch (e) {
+                    if (i % 10 === 0) {
+                        ctx.logger.debug(`[LogCapture] Connection attempt ${i + 1}/${maxRetries} failed: ${e.message}`);
+                    }
+                    await new Promise(r => setTimeout(r, 500));
+                }
+            }
+            ctx.logger.warn('[LogCapture] Failed to connect to browser CDP after multiple attempts.');
+        };
         // Action: Start Browser (Orchestrator)
         ctx.actions.registerAction({
             id: 'browser:start',
             handler: async () => {
                 await syncToStaging();
                 await launchBrowser();
+                connectToBrowser();
                 isInitialized = true;
                 return true;
             }
@@ -83,6 +194,13 @@ const BrowserManagerPlugin = {
             id: 'browser:stop',
             handler: async () => {
                 await ctx.logger.info('Stopping browser...');
+                if (browserConnection) {
+                    try {
+                        browserConnection.disconnect();
+                    }
+                    catch { }
+                    browserConnection = null;
+                }
                 const result = await ctx.actions.runAction('launcher:kill', null);
                 return result;
             }

package/dist/plugins/browser/NativeLauncherPlugin.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import fs from 'fs-extra';
 import { spawn } from 'child_process';
+import os from 'os';
 import { findChrome, normalizePathToWindows } from '../../utils/browserUtils.js';
 let chromeProcess = null;
 const NativeLauncherPlugin = {
@@ -31,8 +32,10 @@ const NativeLauncherPlugin = {
                 let safeProfile = path.join(path.dirname(config.workDir), 'profile');
                 if (process.platform === 'win32') {
                     safeDist = normalizePathToWindows(safeDist);
-                    // Use C:\\Temp profile to avoid permissions issues
-                    safeProfile = 'C:\\\\Temp\\\\ai-ext-profile';
+                    // Use temp profile to avoid permissions issues
+                    // If winStagingDir was passed (from BrowserManager), we could use its sibling
+                    // But here we can just use os.tmpdir
+                    safeProfile = path.join(os.tmpdir(), 'ai-ext-profile');
                 }
                 await ctx.actions.runAction('core:log', { level: 'info', message: `Native Launch Executable: ${executable} ` });
                 await ctx.actions.runAction('core:log', { level: 'info', message: `Native Launch Target: ${safeDist} ` });
@@ -42,6 +45,7 @@ const NativeLauncherPlugin = {
                     '--no-first-run',
                     '--no-default-browser-check',
                     '--disable-gpu',
+                    '--remote-debugging-port=9222', // Enable CDP
                     'chrome://extensions'
                 ];
                 try {

package/dist/plugins/browser/WSLLauncherPlugin.js

@@ -20,9 +20,12 @@ const WSLLauncherPlugin = {
                     await ctx.logger.error('Chrome not found for detached launch.');
                     return false;
                 }
-                // Hardcoded Safe Paths for WSL Strategy
-                const winStagingDir = 'C:\\\\Temp\\\\ai-ext-preview';
-                const winProfile = 'C:\\\\Temp\\\\ai-ext-profile';
+                // Use provided Windows Staging Dir or fallback
+                const winStagingDir = payload.winStagingDir || 'C:\\\\Temp\\\\ai-ext-preview';
+                // Profile dir as sibling to staging dir
+                // Determine sibling safely by manipulating the string or using win path logic
+                // Simple strategy: Replace "ai-ext-preview" with "ai-ext-profile" in the path
+                const winProfile = winStagingDir.replace('ai-ext-preview', 'ai-ext-profile');
                 // Calculate Final Windows Extension Path
                 // We assume payload.extensionPath starts with /mnt/c/Temp/ai-ext-preview
                 // But simplified: We know we sync to STAGING_DIR.
@@ -61,6 +64,9 @@ $argsList = @(
     "--no-first-run",
     "--no-default-browser-check",
     "--disable-gpu",
+    "--remote-debugging-port=9222",
+    "--remote-debugging-address=0.0.0.0",
+    "--remote-allow-origins=*",
     "about:blank"
 )
 

package/dist/utils/browserUtils.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs-extra';
+import { execSync } from 'child_process';
 const CHROME_PATHS = [
     // Standard Windows Paths
     'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
@@ -77,3 +78,23 @@ export const validateExtension = (dir) => {
     }
     return { valid: true };
 };
+// --- Helper to get WSL Temp Paths ---
+export const getWSLTempPath = () => {
+    try {
+        // 1. Get Windows Temp Path via cmd.exe
+        // Output looks like: C:\Users\Name\AppData\Local\Temp
+        const winTemp = execSync('cmd.exe /c echo %TEMP%', { encoding: 'utf-8' }).trim();
+        if (!winTemp)
+            return null;
+        // 2. Convert to WSL path using wslpath utility
+        const wslTemp = execSync(`wslpath -u "${winTemp}"`, { encoding: 'utf-8' }).trim();
+        return {
+            win: winTemp,
+            wsl: wslTemp
+        };
+    }
+    catch (e) {
+        // Fallback or not in WSL
+        return null;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-extension-preview",
-    "version": "0.1.17",
+    "version": "0.1.18",
     "description": "Local preview tool for AI Extension Builder",
     "type": "module",
     "bin": {