ai-extension-preview 0.1.8 → 0.1.10

package/dist/index.js

@@ -41,7 +41,7 @@ async function authenticate(host) {
                 const statusRes = await axios.get(`${host}/preview/status/${sessionId}`);
                 const data = statusRes.data;
                 if (data.status === 'linked') {
-                    console.log(chalk.green('✔ Connected!'));
+                    // console.log(chalk.green('✔ Connected!'));
                     if (!data.jobId) {
                         console.error('Error: No Job ID associated with this connection.');
                         process.exit(1);
@@ -97,7 +97,10 @@ async function main() {
     });
     // 2. Register Plugins
     // Note: In a real dynamic system we might load these from a folder
-    runtime.logger.info('Registering plugins...');
+    // console.log('Registering plugins...');
+    // Register Plugins
+    // UI Plugin first or last? 
+    // If first, it captures subsequent logs.
     runtime.registerPlugin(CorePlugin);
     runtime.registerPlugin(DownloaderPlugin);
     runtime.registerPlugin(BrowserPlugin);

package/dist/plugins/BrowserPlugin.js

@@ -22,7 +22,28 @@ function findChrome() {
     }
     return null;
 }
-const normalizePathToWindows = (p) => {
+// --- 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) {
@@ -31,6 +52,32 @@ const normalizePathToWindows = (p) => {
     // 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',
@@ -64,12 +111,6 @@ 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 });
                 }
@@ -77,35 +118,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 ${extensionRoot}. 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)}` });
@@ -114,44 +139,113 @@ 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. Setup Safe Paths (C:\Temp)
+                // We use the same path that syncToStaging() used (/mnt/c/Temp/ai-ext-preview)
+                const winStagingDir = 'C:\\Temp\\ai-ext-preview';
+                const winProfile = 'C:\\Temp\\ai-ext-profile';
+                let userProfileWin = 'C:\\Temp'; // Legacy variable support
+                const driveLetter = 'c';
+                // Calculate final paths
+                let finalWinExtensionPath = winStagingDir;
+                // Handle nested extension root
+                if (extensionRoot !== STAGING_DIR) {
+                    const relative = path.relative(STAGING_DIR, extensionRoot);
+                    finalWinExtensionPath = path.posix.join(winStagingDir.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';
-                await ctx.actions.runAction('core:log', { level: 'info', message: `WSL Launch Target: ${finalWinDist}` });
-                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
+                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}"
+
+Write-Host "DEBUG: ChromePath: $chromePath"
+Write-Host "DEBUG: ExtPath: $extPath"
+Write-Host "DEBUG: ProfilePath: $profilePath"
+
+# Verify Paths
+if (-not (Test-Path -Path $extPath)) {
+    Write-Host "ERROR: Extension Path NOT FOUND!"
+} else {
+    Write-Host "DEBUG: Extension Path Exists."
+}
+
+# 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",
+    "about:blank"
+)
+
+# Convert to single string to ensure Start-Process handles it safely
+$argStr = $argsList -join " "
+Write-Host "DEBUG: Args: $argStr"
+
+Write-Host "DEBUG: Launching Chrome..."
+Start-Process -FilePath $chromePath -ArgumentList $argStr
 `;
-                const batPath = path.join(STAGING_DIR, 'launch.bat');
-                const winBatPath = 'C:\\Temp\\ai-ext-preview\\launch.bat';
+                // Write ps1 to /mnt/c/Temp/ai-ext-preview/launch.ps1 (Same as STAGING_DIR)
+                const psPath = path.join(STAGING_DIR, 'launch.ps1');
                 try {
-                    fs.writeFileSync(batPath, batContent);
+                    await fs.writeFile(psPath, psContent);
                 }
                 catch (e) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Write Bat Failed: ${e.message}` });
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Write PS1 Failed: ${e.message}` });
                 }
-                const cli = 'cmd.exe';
-                const subprocess = spawn(cli, ['/c', winBatPath], {
+                // Execute via PowerShell (Spawn detached)
+                // psPathWin is C:\\Temp\\ai-ext-preview\\launch.ps1
+                const psPathWin = `${winStagingDir}\\launch.ps1`;
+                const child = spawn('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', psPathWin], {
                     detached: true,
-                    stdio: 'ignore',
-                    cwd: '/mnt/c'
+                    stdio: ['ignore', 'pipe', 'pipe'] // Pipe stderr AND stdout to catch launch errors/debug
+                });
+                if (child.stdout) {
+                    child.stdout.on('data', async (chunk) => {
+                        const msg = chunk.toString();
+                        await ctx.actions.runAction('core:log', { level: 'info', message: `[PS1] ${msg.trim()}` });
+                    });
+                }
+                if (child.stderr) {
+                    child.stderr.on('data', async (chunk) => {
+                        const msg = chunk.toString();
+                        await ctx.actions.runAction('core:log', { level: 'error', message: `Launch Error (Stderr): ${msg}` });
+                        if (msg.includes('Exec format error')) {
+                            await ctx.actions.runAction('core:log', { level: 'error', message: `CRITICAL: WSL Interop is broken. Cannot launch Chrome.` });
+                            await ctx.actions.runAction('core:log', { level: 'error', message: `FIX: Open PowerShell as Admin and run: wsl --shutdown` });
+                            ctx.events.emit('browser:launch-failed', { reason: 'WSL_INTEROP_BROKEN' });
+                        }
+                    });
+                }
+                child.on('error', async (err) => {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `Launch Failed: ${err.message}` });
+                    ctx.events.emit('browser:launch-failed', { reason: err.message });
                 });
-                subprocess.unref();
+                child.unref();
                 return true;
             }
             else {

package/dist/plugins/CorePlugin.js

@@ -32,7 +32,10 @@ export const CorePlugin = {
                         break;
                     default:
                         logger.info(message);
+                        break;
                 }
+                // Emit event for UI
+                ctx.events.emit('log', { level, message, timestamp: new Date().toISOString() });
                 return true;
             }
         });

package/dist/plugins/DownloaderPlugin.js

@@ -54,33 +54,58 @@ 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') {
+                            // Check if files actually exist
+                            let forceDownload = false;
+                            const manifestPath = path.join(DIST_DIR, 'manifest.json');
+                            if (!fs.existsSync(manifestPath)) {
+                                await ctx.actions.runAction('core:log', { level: 'warn', message: 'Version match but files missing. Forcing download...' });
+                                forceDownload = true;
+                            }
+                            if (newVersion !== lastModified || forceDownload) {
+                                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 +195,32 @@ console.log('[Hot Reload] Active for Job:', CURRENT_JOB_ID);
             }
         });
         // Start Polling (Loop)
-        const scheduleNextCheck = () => {
-            checkInterval = setTimeout(async () => {
-                if (!checkInterval)
-                    return; // Disposed
+        void ctx.actions.runAction('core:log', { level: 'info', message: 'Starting polling loop (Interval: 2000ms)' });
+        // Listen for browser failure to stop polling
+        ctx.events.on('browser:launch-failed', () => {
+            if (checkInterval) {
+                clearInterval(checkInterval);
+                checkInterval = undefined;
+                ctx.actions.runAction('core:log', { level: 'warn', message: 'Polling stopped due to browser launch failure.' });
+                // Update status happens in UI
+            }
+        });
+        checkInterval = setInterval(async () => {
+            try {
+                // Use actions for main log (UI Plugin captures this)
+                // console.error('[DownloaderPlugin] Tick - Checking Status...'); // REMOVE (Outside UI)
+                // Silent polling for CLI mode
+                // await ctx.actions.runAction('core:log', { level: 'info', message: '[DEBUG] Polling...' });
                 await ctx.actions.runAction('downloader:check', null);
-                scheduleNextCheck();
-            }, 2000);
-        };
-        scheduleNextCheck();
+            }
+            catch (err) {
+                await ctx.actions.runAction('core:log', { level: 'error', message: `Poll Error: ${err.message}` });
+            }
+        }, 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.8",
+    "version": "0.1.10",
     "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"
     }
 }