ai-extension-preview 0.1.0 → 0.1.2

package/dist/index.js

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs-extra';
+import os from 'os';
 import { Runtime } from 'skeleton-crew-runtime';
 import { CorePlugin } from './plugins/CorePlugin.js';
 import { DownloaderPlugin } from './plugins/DownloaderPlugin.js';
@@ -77,7 +78,10 @@ async function main() {
         userId = authData.userId || userId;
         token = authData.token || token;
     }
-    const WORK_DIR = path.join(process.cwd(), '.preview', jobId);
+    // Use os.homedir() to ensure we have write permissions
+    // Git Bash sometimes defaults cwd to C:\Program Files\Git which causes EPERM
+    const HOME_DIR = os.homedir();
+    const WORK_DIR = path.join(HOME_DIR, '.ai-extension-preview', jobId);
     // 1. Initialize Runtime
     const runtime = new Runtime({
         hostContext: {
@@ -133,4 +137,7 @@ process.on('uncaughtException', (err) => {
 process.on('unhandledRejection', (reason) => {
     console.error('Unhandled Rejection:', reason);
 });
-main();
+main().catch(err => {
+    console.error(chalk.red('Fatal Error:'), err.message || err);
+    process.exit(1);
+});

package/dist/plugins/BrowserPlugin.js

@@ -1,12 +1,18 @@
 import webExt from 'web-ext';
 import path from 'path';
 import { spawn } from 'child_process';
-import fs from 'fs';
+import fs from 'fs-extra';
 const CHROME_PATHS = [
+    // Standard Windows Paths
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+    // WSL Mappings
     '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
     '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+    // Git Bash / Unix-y Windows Environment Mappings
     '/c/Program Files/Google/Chrome/Application/chrome.exe',
     '/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+    // Linux
     '/usr/bin/google-chrome',
     '/usr/bin/chromium'
 ];
@@ -30,33 +36,125 @@ export const BrowserPlugin = {
                 await ctx.actions.runAction('core:log', { level: 'error', message: 'Chrome not found for detached launch.' });
                 return false;
             }
-            // Log with prefix to indicate we are handling the Env quirk
-            await ctx.actions.runAction('core:log', { level: 'info', message: '[WSL] Copying extension to Windows Temp: C:\\ai-ext-preview' });
-            // In a real scenario we might need to copy to a Windows-accessible path if /home/... isn't mapped well,
-            // but usually \\wsl$\... works or user is mapped.
-            // For now assuming direct path works or user has mapping.
-            // Actually, verify path.
-            // IMPORTANT: In WSL, standard linux paths might not be readable by Windows Chrome directly 
-            // without `\\wsl$\...` mapping.
-            // However, previous logs showed "Failed to load... CDP connection closed" which means 
-            // Chrome DID try to load it but failed communication.
-            // So path is likely fine.
+            // WSL Detection & Handling
+            let extensionPath = DIST_DIR;
+            const isWSL = fs.existsSync('/mnt/c'); // Simple check for WSL
+            if (isWSL) {
+                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);
+                    }
+                    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)
+                }
+            }
             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 subprocess = spawn(chromePath, [
-                `--load-extension=${DIST_DIR}`,
+            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;
+            let args = [
+                `--load-extension=${extensionPath}`,
+                `--user-data-dir=${userDataDir}`,
+                '--no-first-run',
+                '--no-default-browser-check',
                 '--disable-gpu',
-                'https://google.com'
-            ], {
-                detached: true,
-                stdio: 'ignore'
-            });
-            subprocess.unref();
-            return true;
+                'about:blank'
+            ];
+            // If WSL, use a batch file to handle the launch robustly
+            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
+                // NOTE: We quote the executable path and arguments carefully
+                // start "" "Executable" args...
+                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';
+                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;
+                }
+                await ctx.actions.runAction('core:log', { level: 'info', message: `EXEC: ${winBatPath}` });
+                // Execute the batch file via cmd.exe using spawn + PATH lookup
+                // We rely on 'cmd.exe' being in the path so spawn works without /bin/sh
+                const executable = 'cmd.exe';
+                await ctx.actions.runAction('core:log', { level: 'info', message: `SPAWN (WSL): ${executable} /c ${winBatPath}` });
+                const subprocess = spawn(executable, ['/c', winBatPath], {
+                    detached: true,
+                    stdio: 'ignore',
+                    cwd: '/mnt/c'
+                });
+                subprocess.unref();
+                return true;
+            }
+            else {
+                // Standard Windows / Linux Launch
+                await ctx.actions.runAction('core:log', { level: 'info', message: `SPAWN: ${chromePath}` });
+                // On Windows, ensure we quote paths correctly if they have spaces?
+                // Node's spawn handles argument quoting automatically usually.
+                // But let's log them to be sure
+                await ctx.actions.runAction('core:log', { level: 'info', message: `ARGS: ${args.join(' ')}` });
+                const subprocess = spawn(executable, args, {
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                subprocess.unref();
+                return true;
+            }
         };
         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

package/dist/plugins/DownloaderPlugin.js

@@ -41,7 +41,11 @@ export const DownloaderPlugin = {
                 rejectUnauthorized: false
             })
         });
+        const VERSION_FILE = path.join(config.workDir, 'version');
         let lastModified = '';
+        if (fs.existsSync(VERSION_FILE)) {
+            lastModified = fs.readFileSync(VERSION_FILE, 'utf-8').trim();
+        }
         let isChecking = false;
         // Action: Check Status
         ctx.actions.registerAction({
@@ -64,6 +68,7 @@ export const DownloaderPlugin = {
                         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 });
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-extension-preview",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "description": "Local preview tool for AI Extension Builder",
     "type": "module",
     "bin": {
@@ -49,4 +49,4 @@
         "tsx": "^4.21.0",
         "typescript": "^5.7.2"
     }
-}
+}