ai-extension-preview 0.1.5 → 0.1.7

package/dist/plugins/BrowserPlugin.js

@@ -1,4 +1,3 @@
-import webExt from 'web-ext';
 import path from 'path';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
@@ -36,82 +35,96 @@ export const BrowserPlugin = {
                 await ctx.actions.runAction('core:log', { level: 'error', message: 'Chrome not found for detached launch.' });
                 return false;
             }
-            // WSL Detection & Handling
-            let extensionPath = DIST_DIR;
-            const isWSL = fs.existsSync('/mnt/c'); // Simple check for WSL
-            if (isWSL) {
+            const isWSL = fs.existsSync('/mnt/c');
+            let executable = chromePath; // Define in scope
+            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
+            // Note: We will evaluate actual extension root later, but base is STAGING_DIR
+            const EXTENSION_PATH = isWSL ? 'C:/Temp/ai-ext-preview' : STAGING_DIR;
+            // --- SYNC FUNCTION ---
+            const syncToStaging = async () => {
                 try {
-                    const WIN_TEMP_DIR = '/mnt/c/Temp/ai-ext-preview';
-                    const WIN_PATH_FOR_CHROME = 'C:/Temp/ai-ext-preview';
-                    // Pre-flight check: Validating WSL Interop
-                    // We try to run cmd.exe simply to check if the OS allows it.
-                    try {
-                        await new Promise((resolve, reject) => {
-                            const check = spawn('cmd.exe', ['/c', 'ver'], { stdio: 'ignore' });
-                            check.on('error', reject);
-                            check.on('close', (code) => {
-                                if (code === 0)
-                                    resolve(true);
-                                else
-                                    reject(new Error(`Exit code ${code}`));
-                            });
-                        });
-                    }
-                    catch (interopErr) {
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `[FATAL] WSL Interop is broken on this system.` });
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `Linux cannot launch Windows applications (cmd.exe failed).` });
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `PLEASE FIX: Open PowerShell as Admin and run 'wsl --shutdown', then restart.` });
-                        return false;
+                    if (fs.existsSync(STAGING_DIR)) {
+                        fs.emptyDirSync(STAGING_DIR);
                     }
-                    await ctx.actions.runAction('core:log', { level: 'info', message: `[WSL] Copying extension to Windows Temp: ${WIN_PATH_FOR_CHROME}` });
-                    // Ensure Windows temp dir exists and is clean
-                    if (fs.existsSync(WIN_TEMP_DIR)) {
-                        fs.removeSync(WIN_TEMP_DIR);
+                    fs.ensureDirSync(STAGING_DIR);
+                    fs.copySync(DIST_DIR, STAGING_DIR);
+                    await ctx.actions.runAction('core:log', { level: 'info', message: `Synced code to Staging` });
+                    // Emit staged event for ServerPlugin (optional for now, but good practice)
+                    ctx.events.emit('browser:staged', { path: STAGING_DIR });
+                }
+                catch (err) {
+                    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;
+                            }
+                        }
                     }
-                    fs.ensureDirSync(WIN_TEMP_DIR);
-                    // Copy dist content
-                    fs.copySync(DIST_DIR, WIN_TEMP_DIR);
-                    extensionPath = WIN_PATH_FOR_CHROME;
                 }
-                catch (copyErr) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to copy to Windows Temp: ${copyErr.message}` });
-                    // Fallback to original path (might fail if not mapped)
+                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.` });
+            }
+            else if (extensionRoot !== STAGING_DIR) {
+                await ctx.actions.runAction('core:log', { level: 'info', message: `Detected nested extension at: ${path.basename(extensionRoot)}` });
             }
-            await ctx.actions.runAction('core:log', { level: 'warning', message: 'Switching to Detached Mode (WSL/GitBash detected).' });
-            await ctx.actions.runAction('core:log', { level: 'info', message: 'Browser polling/logging is disabled. Please reload manually on updates.' });
-            const userDataDir = 'C:/Temp/ai-ext-profile';
-            // Convert Chrome path to Windows format if in WSL
-            // /mnt/c/Program Files/... -> C:\Program Files\...
-            let executable = chromePath;
-            // If WSL, use a batch file to handle the launch robustly
+            // Listen for updates and re-sync
+            ctx.events.on('downloader:updated', async (data) => {
+                await ctx.actions.runAction('core:log', { level: 'info', message: 'Update detected. Syncing to staging...' });
+                await syncToStaging();
+            });
+            await ctx.actions.runAction('core:log', { level: 'info', message: 'Browser running in Detached Mode.' });
+            // Launch Logic
             if (isWSL) {
                 const driveLetter = chromePath.match(/\/mnt\/([a-z])\//)?.[1] || 'c';
                 const winChromePath = chromePath
                     .replace(new RegExp(`^/mnt/${driveLetter}/`), `${driveLetter.toUpperCase()}:\\`)
                     .replace(/\//g, '\\');
-                await ctx.actions.runAction('core:log', { level: 'info', message: `WSL: Creating launch script...` });
-                // Use backslashes for Windows paths in the batch file
-                const winDist = 'C:\\Temp\\ai-ext-preview';
+                // 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';
-                // Create the batch file content
                 const batContent = `@echo off
-start "" "${winChromePath}" --load-extension="${winDist}" --user-data-dir="${winProfile}" --no-first-run --no-default-browser-check --disable-gpu about:blank
+start "" "${winChromePath}" --load-extension="${finalWinDist}" --user-data-dir="${winProfile}" --no-first-run --no-default-browser-check --disable-gpu about:blank
 exit
 `;
-                const batPath = '/mnt/c/Temp/ai-ext-preview/launch.bat';
+                const batPath = path.join(STAGING_DIR, 'launch.bat');
                 const winBatPath = 'C:\\Temp\\ai-ext-preview\\launch.bat';
                 try {
                     fs.writeFileSync(batPath, batContent);
                 }
                 catch (e) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to write batch file: ${e.message}` });
-                    return false;
+                    // Fallback if staging writes fail inside WSL mount for some reason?
                 }
-                await ctx.actions.runAction('core:log', { level: 'info', message: `EXEC: ${winBatPath}` });
-                // Execute the batch file via cmd.exe using spawn + PATH lookup
                 const cli = 'cmd.exe';
-                await ctx.actions.runAction('core:log', { level: 'info', message: `SPAWN (WSL): ${cli} /c ${winBatPath}` });
                 const subprocess = spawn(cli, ['/c', winBatPath], {
                     detached: true,
                     stdio: 'ignore',
@@ -121,22 +134,20 @@ exit
                 return true;
             }
             else {
-                // Standard Windows / Linux Launch (Git Bash / Native)
-                // Normalize paths (stripping trailing slashes which Chrome hates)
-                const safeDist = path.resolve(extensionPath);
-                const safeProfile = path.resolve(userDataDir);
+                // Native Windows / Linux
+                // 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}` });
-                // Reconstruct args with safe paths
                 const cleanArgs = [
                     `--load-extension=${safeDist}`,
                     `--user-data-dir=${safeProfile}`,
                     '--no-first-run',
                     '--no-default-browser-check',
                     '--disable-gpu',
-                    'chrome://extensions' // Better for verifying if it loaded
+                    'chrome://extensions'
                 ];
-                await ctx.actions.runAction('core:log', { level: 'info', message: `ARGS: ${cleanArgs.join(' ')}` });
                 const subprocess = spawn(executable, cleanArgs, {
                     detached: true,
                     stdio: 'ignore'
@@ -148,62 +159,9 @@ exit
         ctx.actions.registerAction({
             id: 'browser:start',
             handler: async () => {
-                // On Windows (including Git Bash), web-ext is unreliable for loading extensions correctly.
-                // We force detached mode to ensure the extension loads.
-                if (process.platform === 'win32') {
-                    await ctx.actions.runAction('core:log', { level: 'warning', message: 'Windows detected: Forcing Detached Mode for reliability.' });
-                    return await launchDetached();
-                }
-                await ctx.actions.runAction('core:log', { level: 'info', message: 'Launching browser...' });
-                try {
-                    // Try web-ext first
-                    const runResult = await webExt.cmd.run({
-                        sourceDir: DIST_DIR,
-                        target: 'chromium',
-                        browserConsole: false,
-                        startUrl: ['https://google.com'],
-                        noInput: true,
-                        keepProfileChanges: false,
-                        args: [
-                            '--start-maximized',
-                            '--no-sandbox',
-                            '--disable-gpu',
-                            '--disable-dev-shm-usage'
-                        ]
-                    }, {
-                        shouldExitProgram: false
-                    });
-                    runner = runResult;
-                    await ctx.actions.runAction('core:log', { level: 'success', message: 'Browser session ended.' });
-                    return true;
-                }
-                catch (err) {
-                    // Check for expected environment failures
-                    if (err.code === 'ECONNRESET' || err.message?.includes('CDP connection closed')) {
-                        // Log specific WSL message for clarity
-                        await ctx.actions.runAction('core:log', { level: 'warning', message: 'WSL: CDP connection dropped (expected). Browser is running detached.' });
-                        await ctx.actions.runAction('core:log', { level: 'info', message: 'Please reload extension manually in Chrome if needed.' });
-                        return await launchDetached();
-                    }
-                    if (err.code !== 'ECONNRESET') {
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `Browser failed: ${err.message}` });
-                    }
-                    return false;
-                }
-            }
-        });
-        ctx.events.on('downloader:updated', async () => {
-            if (runner && runner.reloadAllExtensions) {
-                await ctx.actions.runAction('core:log', { level: 'info', message: 'Triggering browser reload...' });
-                try {
-                    runner.reloadAllExtensions();
-                }
-                catch (e) {
-                    // Ignore
-                }
-            }
-            else {
-                await ctx.actions.runAction('core:log', { level: 'info', message: 'Update installed. Please reload extension in Chrome.' });
+                // Force Detached Mode for Reliability on ALL platforms
+                // This creates the stable "Staging" workflow we want.
+                return await launchDetached();
             }
         });
     }

package/dist/plugins/DownloaderPlugin.js

@@ -69,7 +69,7 @@ export const DownloaderPlugin = {
                         if (success) {
                             lastModified = newVersion;
                             fs.writeFileSync(VERSION_FILE, newVersion);
-                            ctx.events.emit('downloader:updated', { version: job.version });
+                            ctx.events.emit('downloader:updated', { version: job.version, jobId: config.jobId });
                         }
                     }
                     isChecking = false;
@@ -101,24 +101,35 @@ export const DownloaderPlugin = {
                     try {
                         const HOT_RELOAD_CODE = `
 const EVENT_SOURCE_URL = 'http://localhost:3500/status';
+const CURRENT_JOB_ID = '${config.jobId}';
 let lastVersion = null;
+let lastJobId = null;
 
 setInterval(async () => {
     try {
         const res = await fetch(EVENT_SOURCE_URL);
         const data = await res.json();
         
+        // 1. Job ID Swap (User switched project)
+        if (data.jobId && data.jobId !== CURRENT_JOB_ID) {
+             console.log('[Hot Reload] Job Swap detected. Reloading...');
+             chrome.runtime.reload();
+             return;
+        }
+
+        // 2. Version Bump (Same project, new build)
         if (lastVersion && data.version !== lastVersion) {
             console.log('[Hot Reload] New version detected:', data.version);
             chrome.runtime.reload();
         }
         
         lastVersion = data.version;
+        lastJobId = data.jobId;
     } catch (err) {
         // Build tool might be offline
     }
 }, 1000);
-console.log('[Hot Reload] Active');
+console.log('[Hot Reload] Active for Job:', CURRENT_JOB_ID);
 `;
                         const hotReloadPath = path.join(DIST_DIR, 'hot-reload.js');
                         await fs.writeFile(hotReloadPath, HOT_RELOAD_CODE);

package/dist/plugins/ServerPlugin.js

@@ -23,8 +23,12 @@ export const ServerPlugin = {
                 return;
             }
             if (req.url === '/status') {
+                const currentJobId = ctx.host.config.jobId;
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ version: currentVersion }));
+                res.end(JSON.stringify({
+                    version: currentVersion,
+                    jobId: currentJobId
+                }));
             }
             else {
                 res.writeHead(404);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-extension-preview",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "Local preview tool for AI Extension Builder",
     "type": "module",
     "bin": {
@@ -20,7 +20,7 @@
     "author": "AI Extension Builder",
     "license": "MIT",
     "scripts": {
-        "build": "shx rm -rf dist && tsc -b",
+        "build": "shx rm -rf dist && tsc -b && shx chmod +x dist/index.js",
         "start": "tsx src/index.ts",
         "dev": "tsx watch src/index.ts",
         "preview": "node dist/index.js"
@@ -49,4 +49,4 @@
         "tsx": "^4.21.0",
         "typescript": "^5.7.2"
     }
-}
+}