ai-extension-preview 0.1.7 → 0.1.9

package/dist/plugins/BrowserPlugin.js

@@ -22,6 +22,62 @@ function findChrome() {
     }
     return null;
 }
+// --- Helper to find actual extension root (handle nested folder in zip) ---
+export const findExtensionRoot = (dir) => {
+    if (fs.existsSync(path.join(dir, 'manifest.json')))
+        return dir;
+    // Check immediate subdirectories (depth 1)
+    try {
+        const items = fs.readdirSync(dir);
+        for (const item of items) {
+            const fullPath = path.join(dir, item);
+            if (fs.statSync(fullPath).isDirectory()) {
+                if (fs.existsSync(path.join(fullPath, 'manifest.json'))) {
+                    return fullPath;
+                }
+            }
+        }
+    }
+    catch (e) {
+        // Dir might be empty or invalid
+    }
+    return null;
+};
+export const normalizePathToWindows = (p) => {
+    // Handle Git Bash /c/ style
+    const gitBashMatch = p.match(/^\/([a-z])\/(.*)/i);
+    if (gitBashMatch) {
+        return `${gitBashMatch[1].toUpperCase()}:\\${gitBashMatch[2].replace(/\//g, '\\')}`;
+    }
+    // Handle Forward slashes
+    return p.replace(/\//g, '\\');
+};
+export const stripTrailingSlash = (p) => {
+    return p.replace(/[\\\/]+$/, '');
+};
+// --- Helper to validate extension directory existence and structure ---
+export const validateExtension = (dir) => {
+    if (!fs.existsSync(dir)) {
+        return { valid: false, error: 'Directory does not exist' };
+    }
+    const stats = fs.statSync(dir);
+    if (!stats.isDirectory()) {
+        return { valid: false, error: 'Path is not a directory' };
+    }
+    const manifestPath = path.join(dir, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        return { valid: false, error: 'manifest.json missing' };
+    }
+    // Basic JSON validity check
+    try {
+        const content = fs.readFileSync(manifestPath, 'utf-8');
+        JSON.parse(content);
+    }
+    catch (e) {
+        return { valid: false, error: 'manifest.json is invalid JSON' };
+    }
+    return { valid: true };
+};
 export const BrowserPlugin = {
     name: 'browser',
     version: '1.0.0',
@@ -36,7 +92,11 @@ export const BrowserPlugin = {
                 return false;
             }
             const isWSL = fs.existsSync('/mnt/c');
-            let executable = chromePath; // Define in scope
+            let executable = chromePath;
+            // Normalize Executable for Native Windows (Git Bash)
+            if (!isWSL && process.platform === 'win32') {
+                executable = normalizePathToWindows(chromePath);
+            }
             const STAGING_DIR = isWSL ? '/mnt/c/Temp/ai-ext-preview' : path.join(config.workDir, '../staging');
             const WIN_PROFILE_DIR = 'C:/Temp/ai-ext-profile';
             // For native windows/linux, use local staging path
@@ -51,6 +111,12 @@ export const BrowserPlugin = {
                     fs.ensureDirSync(STAGING_DIR);
                     fs.copySync(DIST_DIR, STAGING_DIR);
                     await ctx.actions.runAction('core:log', { level: 'info', message: `Synced code to Staging` });
+                    // DEBUG: Log contents of staging
+                    try {
+                        const files = fs.readdirSync(STAGING_DIR);
+                        await ctx.actions.runAction('core:log', { level: 'info', message: `Staging Contents: ${files.join(', ')}` });
+                    }
+                    catch (e) { }
                     // Emit staged event for ServerPlugin (optional for now, but good practice)
                     ctx.events.emit('browser:staged', { path: STAGING_DIR });
                 }
@@ -58,34 +124,19 @@ export const BrowserPlugin = {
                     await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to sync to staging: ${err.message}` });
                 }
             };
-            // --- Helper to find actual extension root (handle nested folder in zip) ---
-            const findExtensionRoot = (dir) => {
-                if (fs.existsSync(path.join(dir, 'manifest.json')))
-                    return dir;
-                // Check immediate subdirectories (depth 1)
-                try {
-                    const items = fs.readdirSync(dir);
-                    for (const item of items) {
-                        const fullPath = path.join(dir, item);
-                        if (fs.statSync(fullPath).isDirectory()) {
-                            if (fs.existsSync(path.join(fullPath, 'manifest.json'))) {
-                                return fullPath;
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    // Dir might be empty or invalid
-                }
-                return null;
-            };
             // Initial Sync
             await syncToStaging();
             // Resolve proper root AFTER sync
             let extensionRoot = findExtensionRoot(STAGING_DIR) || STAGING_DIR;
             // Check if we found a valid root
-            if (!fs.existsSync(path.join(extensionRoot, 'manifest.json'))) {
-                await ctx.actions.runAction('core:log', { level: 'error', message: `[CRITICAL] manifest.json not found in ${STAGING_DIR}. Extension will not load.` });
+            const validation = validateExtension(extensionRoot);
+            if (!validation.valid) {
+                await ctx.actions.runAction('core:log', { level: 'error', message: `[CRITICAL] Extension validation failed: ${validation.error} in ${extensionRoot}` });
+                await ctx.actions.runAction('core:log', { level: 'info', message: `Checked Path: ${extensionRoot}` });
+                // We proceed anyway? Or should we stop? 
+                // Previous logic proceeded but logged critical error. 
+                // Let's keep it logging critical but maybe return false if we wanted to be strict.
+                // However, user might fix it live.
             }
             else if (extensionRoot !== STAGING_DIR) {
                 await ctx.actions.runAction('core:log', { level: 'info', message: `Detected nested extension at: ${path.basename(extensionRoot)}` });
@@ -94,43 +145,107 @@ export const BrowserPlugin = {
             ctx.events.on('downloader:updated', async (data) => {
                 await ctx.actions.runAction('core:log', { level: 'info', message: 'Update detected. Syncing to staging...' });
                 await syncToStaging();
+                // Re-validate on update? 
+                // const newRoot = findExtensionRoot(STAGING_DIR) || STAGING_DIR;
+                // const newValidation = validateExtension(newRoot);
+                // if (!newValidation.valid) ...
             });
             await ctx.actions.runAction('core:log', { level: 'info', message: 'Browser running in Detached Mode.' });
             // Launch Logic
+            // Launch Logic
             if (isWSL) {
-                const driveLetter = chromePath.match(/\/mnt\/([a-z])\//)?.[1] || 'c';
+                // -------------------------------------------------------------------------
+                // WSL STRATEGY (Validated 2025-12-24)
+                // 1. Use Windows User Profile for staging to avoid Permission/Path issues
+                // 2. Use PowerShell script to launch Chrome to reliably pass arguments
+                // -------------------------------------------------------------------------
+                // 1. Get Windows User Profile Path
+                let userProfileWin = '';
+                try {
+                    // Use async exec to avoid blocking
+                    const { exec } = await import('child_process');
+                    const util = await import('util');
+                    const execAsync = util.promisify(exec);
+                    const { stdout } = await execAsync('cmd.exe /c echo %USERPROFILE%', { encoding: 'utf8' });
+                    userProfileWin = stdout.trim();
+                }
+                catch (e) {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: 'Failed to detect Windows User Profile. Defaulting to C:\\Temp' });
+                    userProfileWin = 'C:\\Temp';
+                }
+                const stagingDirName = '.ai-extension-preview';
+                const stagingDirWin = path.posix.join(userProfileWin.replace(/\\/g, '/'), stagingDirName).replace(/\//g, '\\');
+                // Map Win Path -> WSL Path for copying
+                const driveMatch = userProfileWin.match(/^([a-zA-Z]):/);
+                const driveLetter = driveMatch ? driveMatch[1].toLowerCase() : 'c';
+                const userProfileRoute = userProfileWin.substring(3).replace(/\\/g, '/'); // Users/Name
+                const wslStagingBase = `/mnt/${driveLetter}/${userProfileRoute}`;
+                const wslStagingDir = path.posix.join(wslStagingBase, stagingDirName);
+                try {
+                    if (await fs.pathExists(wslStagingDir))
+                        await fs.remove(wslStagingDir);
+                    // Use async copy to prevent blocking event loop (Fixes 25s lag)
+                    await fs.copy(STAGING_DIR, wslStagingDir);
+                }
+                catch (copyErr) {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Staging Copy Failed: ${copyErr.message}` });
+                }
+                // Calculate final paths
+                let finalWinExtensionPath = stagingDirWin;
+                // Handle nested extension root
+                if (extensionRoot !== STAGING_DIR) {
+                    const relative = path.relative(STAGING_DIR, extensionRoot);
+                    finalWinExtensionPath = path.posix.join(stagingDirWin.replace(/\\/g, '/'), relative).replace(/\//g, '\\');
+                }
                 const winChromePath = chromePath
                     .replace(new RegExp(`^/mnt/${driveLetter}/`), `${driveLetter.toUpperCase()}:\\`)
                     .replace(/\//g, '\\');
-                // Calculate Windows path for the extension root
-                // Base Win: C:\Temp\ai-ext-preview
-                // Base Linux: /mnt/c/Temp/ai-ext-preview
-                // If extensionRoot is /mnt/c/Temp/ai-ext-preview/subdir => C:\Temp\ai-ext-preview\subdir
-                // Use relative path logic to be safe
-                const baseLinux = '/mnt/c/Temp/ai-ext-preview';
-                const relative = path.relative(baseLinux, extensionRoot);
-                const winDistRoot = relative ? `C:\\Temp\\ai-ext-preview\\${relative}` : 'C:\\Temp\\ai-ext-preview';
-                const finalWinDist = winDistRoot.replace(/\//g, '\\');
-                const winProfile = 'C:\\Temp\\ai-ext-profile';
-                const batContent = `@echo off
-start "" "${winChromePath}" --load-extension="${finalWinDist}" --user-data-dir="${winProfile}" --no-first-run --no-default-browser-check --disable-gpu about:blank
-exit
+                const winProfile = path.posix.join(userProfileWin.replace(/\\/g, '/'), '.ai-extension-profile').replace(/\//g, '\\');
+                await ctx.actions.runAction('core:log', { level: 'info', message: `WSL Launch Target (Win): ${finalWinExtensionPath}` });
+                // await ctx.actions.runAction('core:log', { level: 'info', message: `WSL Profile (Win): ${winProfile}` });
+                // Create PowerShell Launch Script
+                const psContent = `
+$chromePath = "${winChromePath}"
+$extPath = "${finalWinExtensionPath}"
+$profilePath = "${winProfile}"
+
+# Create Profile Dir if needed
+if (-not (Test-Path -Path $profilePath)) {
+    New-Item -ItemType Directory -Force -Path $profilePath | Out-Null
+}
+
+$argsList = @(
+    "--load-extension=$extPath",
+    "--user-data-dir=$profilePath",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-gpu",
+    "chrome://extensions"
+)
+
+Start-Process -FilePath $chromePath -ArgumentList $argsList
 `;
-                const batPath = path.join(STAGING_DIR, 'launch.bat');
-                const winBatPath = 'C:\\Temp\\ai-ext-preview\\launch.bat';
+                const psPath = path.join(wslStagingDir, 'launch.ps1');
+                const winPsPath = path.posix.join(stagingDirWin.replace(/\\/g, '/'), 'launch.ps1').replace(/\//g, '\\');
                 try {
-                    fs.writeFileSync(batPath, batContent);
+                    await fs.writeFile(psPath, psContent);
                 }
                 catch (e) {
-                    // Fallback if staging writes fail inside WSL mount for some reason?
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Write PS1 Failed: ${e.message}` });
+                }
+                // Execute PowerShell
+                const cli = 'powershell.exe';
+                try {
+                    const subprocess = spawn(cli, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', winPsPath], {
+                        detached: true, // We still detach the PowerShell process itself
+                        stdio: 'ignore',
+                        cwd: `/mnt/${driveLetter}`
+                    });
+                    subprocess.unref();
+                }
+                catch (spawnErr) {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Spawn Error: ${spawnErr.message}` });
                 }
-                const cli = 'cmd.exe';
-                const subprocess = spawn(cli, ['/c', winBatPath], {
-                    detached: true,
-                    stdio: 'ignore',
-                    cwd: '/mnt/c'
-                });
-                subprocess.unref();
                 return true;
             }
             else {
@@ -138,8 +253,8 @@ exit
                 // Use extensionRoot which points to the detected subfolder or root
                 const safeDist = path.resolve(extensionRoot);
                 const safeProfile = path.join(path.dirname(config.workDir), 'profile'); // ~/.ai-extension-preview/profile
-                await ctx.actions.runAction('core:log', { level: 'info', message: `SPAWN: ${executable}` });
-                await ctx.actions.runAction('core:log', { level: 'info', message: `EXT PATH: ${safeDist}` });
+                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}` });
                 const cleanArgs = [
                     `--load-extension=${safeDist}`,
                     `--user-data-dir=${safeProfile}`,
@@ -148,11 +263,16 @@ exit
                     '--disable-gpu',
                     'chrome://extensions'
                 ];
-                const subprocess = spawn(executable, cleanArgs, {
-                    detached: true,
-                    stdio: 'ignore'
-                });
-                subprocess.unref();
+                try {
+                    const subprocess = spawn(executable, cleanArgs, {
+                        detached: true,
+                        stdio: 'ignore'
+                    });
+                    subprocess.unref();
+                }
+                catch (spawnErr) {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `Spawn Failed: ${spawnErr.message}` });
+                }
                 return true;
             }
         };

package/dist/plugins/DownloaderPlugin.js

@@ -54,33 +54,49 @@ export const DownloaderPlugin = {
                 if (isChecking)
                     return true; // Skip if busy
                 isChecking = true;
-                try {
-                    const res = await client.get(`/jobs/${config.jobId}`);
-                    const job = res.data;
-                    const newVersion = job.version;
-                    // If no version in job yet, fall back to timestamp or ignore
-                    if (!newVersion && !lastModified) {
-                        // First run, just verify it exists
-                        // We might want to download anyway if we don't have it locally
+                const MAX_RETRIES = 3;
+                let attempt = 0;
+                while (attempt < MAX_RETRIES) {
+                    try {
+                        const res = await client.get(`/jobs/${config.jobId}`);
+                        const job = res.data;
+                        const newVersion = job.version;
+                        // If no version in job yet, fall back to timestamp or ignore
+                        if (!newVersion && !lastModified) {
+                            // First run, just verify it exists
+                        }
+                        if (job.status === 'completed') {
+                            if (newVersion !== lastModified) {
+                                await ctx.actions.runAction('core:log', { level: 'info', message: `New version detected (Old: "${lastModified}", New: "${newVersion}")` });
+                                const success = await ctx.actions.runAction('downloader:download', null);
+                                if (success) {
+                                    lastModified = newVersion;
+                                    fs.writeFileSync(VERSION_FILE, newVersion);
+                                    ctx.events.emit('downloader:updated', { version: job.version, jobId: config.jobId });
+                                }
+                            }
+                        }
+                        else {
+                            // await ctx.actions.runAction('core:log', { level: 'info', message: `Poll: Job status is ${job.status}` });
+                        }
+                        isChecking = false;
+                        return true;
                     }
-                    if (job.status === 'completed' && newVersion !== lastModified) {
-                        await ctx.actions.runAction('core:log', { level: 'info', message: `New version detected (Old: "${lastModified}", New: "${newVersion}")` });
-                        const success = await ctx.actions.runAction('downloader:download', null);
-                        if (success) {
-                            lastModified = newVersion;
-                            fs.writeFileSync(VERSION_FILE, newVersion);
-                            ctx.events.emit('downloader:updated', { version: job.version, jobId: config.jobId });
+                    catch (error) {
+                        attempt++;
+                        const isNetworkError = error.code === 'EAI_AGAIN' || error.code === 'ENOTFOUND' || error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
+                        if (attempt < MAX_RETRIES && isNetworkError) {
+                            await ctx.actions.runAction('core:log', { level: 'warn', message: `Connection failed (${error.code}). Retrying (${attempt}/${MAX_RETRIES})...` });
+                            await new Promise(r => setTimeout(r, 1000 * attempt)); // Backoff
+                            continue;
                         }
+                        isChecking = false;
+                        await ctx.actions.runAction('core:log', { level: 'error', message: `Check failed: ${error.message}` });
+                        return false;
                     }
-                    isChecking = false;
-                    return true;
-                }
-                catch (error) {
-                    isChecking = false;
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Check failed: ${error.message}` });
-                    // Return false only on actual error, so index.ts knows to fail
-                    return true;
                 }
+                isChecking = false;
+                return false;
             }
         });
         // Action: Download
@@ -170,19 +186,22 @@ console.log('[Hot Reload] Active for Job:', CURRENT_JOB_ID);
             }
         });
         // Start Polling (Loop)
-        const scheduleNextCheck = () => {
-            checkInterval = setTimeout(async () => {
-                if (!checkInterval)
-                    return; // Disposed
+        console.error('[DownloaderPlugin] Starting polling loop (Interval: 2000ms)');
+        checkInterval = setInterval(async () => {
+            try {
+                // Use actions for main log, but console.error for guaranteed debug output
+                // await ctx.actions.runAction('core:log', { level: 'info', message: '[DEBUG] Polling Tick...' });
+                console.error('[DownloaderPlugin] Tick - Checking Status...');
                 await ctx.actions.runAction('downloader:check', null);
-                scheduleNextCheck();
-            }, 2000);
-        };
-        scheduleNextCheck();
+            }
+            catch (err) {
+                console.error('[DownloaderPlugin] Poll Error:', err);
+            }
+        }, 2000);
     },
     dispose(ctx) {
         if (checkInterval) {
-            clearTimeout(checkInterval);
+            clearInterval(checkInterval);
             checkInterval = undefined;
         }
     }

package/dist/plugins/ServerPlugin.js

@@ -24,6 +24,7 @@ export const ServerPlugin = {
             }
             if (req.url === '/status') {
                 const currentJobId = ctx.host.config.jobId;
+                ctx.actions.runAction('core:log', { level: 'info', message: `[DEBUG] Server: Extension requested status (Reporting: ${currentVersion})` });
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
                     version: currentVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-extension-preview",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "description": "Local preview tool for AI Extension Builder",
     "type": "module",
     "bin": {
@@ -47,6 +47,7 @@
         "@types/ws": "^8.5.13",
         "shx": "^0.4.0",
         "tsx": "^4.21.0",
-        "typescript": "^5.7.2"
+        "typescript": "^5.7.2",
+        "vitest": "^4.0.16"
     }
 }