ai-extension-preview 0.1.4 → 0.1.6

package/dist/index.js

@@ -9,6 +9,7 @@ import { Runtime } from 'skeleton-crew-runtime';
 import { CorePlugin } from './plugins/CorePlugin.js';
 import { DownloaderPlugin } from './plugins/DownloaderPlugin.js';
 import { BrowserPlugin } from './plugins/BrowserPlugin.js';
+import { ServerPlugin } from './plugins/ServerPlugin.js';
 import axios from 'axios';
 import chalk from 'chalk';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -100,6 +101,7 @@ async function main() {
     runtime.registerPlugin(CorePlugin);
     runtime.registerPlugin(DownloaderPlugin);
     runtime.registerPlugin(BrowserPlugin);
+    runtime.registerPlugin(ServerPlugin);
     runtime.logger.info('Initializing runtime...');
     await runtime.initialize();
     const ctx = runtime.getContext();

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,59 @@ 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
+            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;
-                    }
-                    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);
+                    if (fs.existsSync(STAGING_DIR)) {
+                        fs.emptyDirSync(STAGING_DIR);
                     }
-                    fs.ensureDirSync(WIN_TEMP_DIR);
-                    // Copy dist content
-                    fs.copySync(DIST_DIR, WIN_TEMP_DIR);
-                    extensionPath = WIN_PATH_FOR_CHROME;
+                    fs.ensureDirSync(STAGING_DIR);
+                    fs.copySync(DIST_DIR, STAGING_DIR);
+                    await ctx.actions.runAction('core:log', { level: 'info', message: `Synced code to Staging: ${EXTENSION_PATH}` });
+                    // Emit staged event for ServerPlugin (optional for now, but good practice)
+                    ctx.events.emit('browser:staged', { path: STAGING_DIR });
                 }
-                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 (err) {
+                    await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to sync to staging: ${err.message}` });
                 }
-            }
-            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
+            };
+            // Initial Sync
+            await syncToStaging();
+            // 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';
                 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
-exit
-`;
-                const batPath = '/mnt/c/Temp/ai-ext-preview/launch.bat';
+    start "" "${winChromePath}" --load-extension="${winDist}" --user-data-dir="${winProfile}" --no-first-run --no-default-browser-check --disable-gpu about:blank
+    exit
+    `;
+                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?
+                    // Should satisfy since we verified interop before?
+                    // Actually verification was removed in this block, let's assume it works or fail.
                 }
-                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 +97,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
+                const safeDist = path.resolve(STAGING_DIR);
+                // Linux/Mac/Win Native Profile Path
+                // We need a stable profile path for native too to keep Detached session alive/resuable
+                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 +122,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;
@@ -97,6 +97,68 @@ export const DownloaderPlugin = {
                     await fs.emptyDir(DIST_DIR);
                     const zip = new AdmZip(DOWNLOAD_PATH);
                     zip.extractAllTo(DIST_DIR, true);
+                    // --- HOT RELOAD INJECTION ---
+                    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 for Job:', CURRENT_JOB_ID);
+`;
+                        const hotReloadPath = path.join(DIST_DIR, 'hot-reload.js');
+                        await fs.writeFile(hotReloadPath, HOT_RELOAD_CODE);
+                        // Patch Manifest / Background
+                        const manifestPath = path.join(DIST_DIR, 'manifest.json');
+                        if (await fs.pathExists(manifestPath)) {
+                            const manifest = await fs.readJson(manifestPath);
+                            // MV3 Module Worker Strategy
+                            if (manifest.manifest_version === 3 && manifest.background?.service_worker) {
+                                const swPath = path.join(DIST_DIR, manifest.background.service_worker);
+                                if (await fs.pathExists(swPath)) {
+                                    const swContent = await fs.readFile(swPath, 'utf-8');
+                                    // Prepend import
+                                    await fs.writeFile(swPath, "import './hot-reload.js';\n" + swContent);
+                                    await ctx.actions.runAction('core:log', { level: 'info', message: 'Injected Hot Reload script into background worker.' });
+                                }
+                            }
+                            // MV2 Scripts Strategy (Fallback if user generates MV2)
+                            else if (manifest.background?.scripts) {
+                                manifest.background.scripts.push('hot-reload.js');
+                                await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+                                await ctx.actions.runAction('core:log', { level: 'info', message: 'Injected Hot Reload script into background scripts.' });
+                            }
+                        }
+                    }
+                    catch (injectErr) {
+                        await ctx.actions.runAction('core:log', { level: 'error', message: `Hot Reload Injection Failed: ${injectErr.message}` });
+                    }
+                    // ----------------------------
                     spinner.succeed('Updated extension code!');
                     return true;
                 }

package/dist/plugins/ServerPlugin.js

@@ -0,0 +1,58 @@
+import http from 'http';
+export const ServerPlugin = {
+    name: 'server',
+    version: '1.0.0',
+    setup(ctx) {
+        let currentVersion = '0.0.0';
+        const PORT = 3500;
+        // Listen for version updates
+        ctx.events.on('downloader:updated', (data) => {
+            if (data && data.version) {
+                currentVersion = data.version;
+                ctx.actions.runAction('core:log', { level: 'info', message: `Server: Reporting version ${currentVersion}` });
+            }
+        });
+        const server = http.createServer((req, res) => {
+            // CORS Headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.url === '/status') {
+                const currentJobId = ctx.host.config.jobId;
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    version: currentVersion,
+                    jobId: currentJobId
+                }));
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not Found');
+            }
+        });
+        server.listen(PORT, () => {
+            ctx.actions.runAction('core:log', { level: 'info', message: `Hot Reload Server running on port ${PORT}` });
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                ctx.actions.runAction('core:log', { level: 'error', message: `Port ${PORT} is busy. Hot reload may fail.` });
+            }
+            else {
+                ctx.actions.runAction('core:log', { level: 'error', message: `Server error: ${err.message}` });
+            }
+        });
+        // Store server instance to close later
+        ctx._serverInstance = server;
+    },
+    dispose(ctx) {
+        const server = ctx._serverInstance;
+        if (server) {
+            server.close();
+        }
+    }
+};

package/package.json

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